def unauthorized_redirect(app):
lm = LoginManager()
lm.login_view = "login"
lm.setup_app(app)
res = lm.unauthorized()
assert res.headers["Location"] == "/login?next=%2F"
assert LOGIN_MESSAGE in get_flashed_messages()
def unauthorized_callback(app):
lm = LoginManager()
lm.login_view = "login"
@lm.unauthorized_handler
def unauth():
return "UNAUTHORIZED!"
lm.setup_app(app)
assert lm.unauthorized() == "UNAUTHORIZED!"
assert len(get_flashed_messages()) == 0
def configure_login_manager(app):
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.login_view = "login"
login_manager.login_message = u"You must login!"
@login_manager.user_loader
def load_user(user_id):
beaker_session = request.environ['beaker.session']
beaker_user_id = beaker_session['user_id']
#user = User()
#user.id = beaker_user_id #use user_id in beaker!
return user
def create_users_blueprint(app, _db, login_redirect_view='main'):
global db
db = _db
from .models import User
from .forms import LoginForm, RegisterForm
users_blueprint = Blueprint('users', __name__, template_folder='templates', static_folder='static')
bcrypt = Bcrypt(app)
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.login_view = 'users.login'
@login_manager.user_loader
def user_loader(user_id):
return User.query.get(user_id)
@users_blueprint.route('/login/', methods=['GET', 'POST'])
def login():
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if user is None or bcrypt.check_password_hash(user.password, form.password):
flash("Invalid email or password", "error")
else:
login_user(user)
flash("Login successful", 'success')
return redirect(url_for(login_redirect_view))
return render_template('users/login.html', form=form)
@users_blueprint.route('/logout/')
@login_required
def logout():
logout_user()
return redirect(url_for(login_redirect_view))
@users_blueprint.route('/register/', methods=['GET', 'POST'])
def register():
form = RegisterForm()
if form.validate_on_submit():
user = User(form.email.data, bcrypt.generate_password_hash(form.password.data))
db.session.add(user)
db.session.commit()
login_user(user)
flash("Login successful")
return redirect(url_for(login_redirect_view))
return render_template('users/register.html', form=form)
return users_blueprint
def login_message(app):
lm = LoginManager()
lm.login_view = "login"
lm.login_message = u"Log in or the owl will eat you."
lm.setup_app(app)
lm.unauthorized()
assert u"Log in or the owl will eat you." in get_flashed_messages()
def init_app(self, app):
if app is None:
return
blueprint = Blueprint(AUTH_CONFIG_KEY.lower(), __name__)
config = default_config.copy()
try:
config.update(app.config.get(AUTH_CONFIG_KEY, {}))
except:
pass
app.config[AUTH_CONFIG_KEY] = config
app.logger.debug("Auth Configuration: %s" % config)
# setup the login manager extension
login_manager = LoginManager()
login_manager.anonymous_user = Anonymous
login_manager.login_view = config[LOGIN_VIEW_KEY]
login_manager.setup_app(app)
# get some things form the config
Provider = get_class_from_config(AUTH_PROVIDER_KEY, config)
Encryptor = get_class_from_config(PASSWORD_ENCRYPTOR_KEY, config)
Form = get_class_from_config(LOGIN_FORM_CLASS_KEY, config)
# create the service and auth provider and add it to the app
# so it can be referenced elsewhere
app.login_manager = login_manager
app.password_encryptor = Encryptor(config[SALT_KEY])
app.auth_provider = Provider(Form)
DEBUG_LOGIN = "******"
ERROR_LOGIN = "******"
DEBUG_LOGOUT = "User logged out, redirecting to: %s"
FLASH_INACTIVE = "Inactive user"
@login_manager.user_loader
def load_user(id):
try:
return user_service.get_user_with_id(id)
except Exception, e:
current_app.logger.error("Error getting user: %s" % e)
return None
def setup_interactive(app):
lm = LoginManager()
lm.login_view = "login"
lm.user_loader(get_user)
@lm.unauthorized_handler
def unauth():
return "UNAUTHORIZED!"
lm.setup_app(app)
def logging_in(app):
lm = LoginManager()
lm.login_view = "login"
lm.user_loader(get_user)
lm.setup_app(app)
app.preprocess_request()
assert not current_user.is_authenticated()
assert current_user.is_anonymous()
with assert_fired(user_logged_in):
login_user(notch)
assert current_user.name == u"Notch"
assert session["user_id"] == u"1"
def init_app(self, app):
if app is None: return
blueprint = Blueprint(AUTH_CONFIG_KEY.lower(), __name__)
config = default_config.copy()
try:
config.update(app.config.get(AUTH_CONFIG_KEY, {}))
except:
pass
app.config[AUTH_CONFIG_KEY] = config
app.logger.debug("Auth Configuration: %s" % config)
# setup the login manager extension
login_manager = LoginManager()
login_manager.anonymous_user = Anonymous
login_manager.login_view = config[LOGIN_VIEW_KEY]
login_manager.setup_app(app)
# get some things form the config
Provider = get_class_from_config(AUTH_PROVIDER_KEY, config)
Encryptor = get_class_from_config(PASSWORD_ENCRYPTOR_KEY, config)
Form = get_class_from_config(LOGIN_FORM_CLASS_KEY, config)
# create the service and auth provider and add it to the app
# so it can be referenced elsewhere
app.login_manager = login_manager
app.password_encryptor = Encryptor(config[SALT_KEY])
app.auth_provider = Provider(Form)
DEBUG_LOGIN = '******'
ERROR_LOGIN = '******'
DEBUG_LOGOUT = 'User logged out, redirecting to: %s'
FLASH_INACTIVE = 'Inactive user'
@login_manager.user_loader
def load_user(id):
try:
return user_service.get_user_with_id(id)
except Exception, e:
current_app.logger.error('Error getting user: %s' % e)
return None
import json
from urllib import urlencode
from urlparse import parse_qs, parse_qsl, urlsplit, urlunsplit
from flask import redirect, request, session, url_for
from flaskext.login import LoginManager, login_user, logout_user
import oauth2
import requests
from makerbase import app
from makerbase.models import User
login_manager = LoginManager()
login_manager.setup_app(app, add_context_processor=True)
login_manager.user_loader(User.get)
@app.route('/signin/github')
def signin_github():
try:
next_url = request.args['next']
except KeyError:
pass
else:
session['signin_next_url'] = next_url
urlparts = urlsplit(request.base_url)
params = {
'client_id': app.config['GITHUB_CLIENT_ID'],
'redirect_url': urlunsplit((urlparts.scheme, urlparts.netloc, url_for('complete_github'), None, None)),
########################## Error Handlers ##########################
@app.errorhandler(404)
def page_not_found(e):
return render_template('cms_404.html'), 404
@app.errorhandler(500)
def page_not_found(e):
return render_template('cms_500.html'), 500
########################## User Authentication and Registration ##########################
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.login_view = "/login/"
login_manager.login_message = u"You need to login to access this resource."
class User(UserMixin):
def __init__(self, email, key_id):
self.name = email
self.id = key_id
self.user = db.get(self.id)
def is_active(self):
if self.user.active == True:
return True
else:
ASC = pymongo.ASCENDING
import flask
from functools import wraps
from base import app, getDBConnection
from flask import render_template, request, abort, Blueprint, url_for, make_response
from flaskext.login import login_required, login_user, current_user, logout_user
login_page = Blueprint("users", __name__, template_folder='templates')
import utils
logger = utils.make_logger(login_page)
import re
allowed_usernames = re.compile("^[a-zA-Z0-9._-]+$")
from flaskext.login import LoginManager
login_manager = LoginManager()
import pwdmanager
from pwdmanager import LmfdbUser, LmfdbAnonymousUser
# TODO update this url, needed for the user login token
base_url = "http://www.l-functions.org"
@login_manager.user_loader
def load_user(userid):
from pwdmanager import LmfdbUser
return LmfdbUser(userid)
login_manager.login_view = "users.info"
# this anonymous user has the is_admin() method
from flask import Flask, redirect, request, url_for
www = Flask(__name__)
www.config.from_pyfile('../config.cfg')
from flaskext.login import LoginManager, current_user
login = LoginManager()
login.setup_app(www, add_context_processor=True)
login.login_view = 'login'
from flaskext.sqlalchemy import SQLAlchemy
db = SQLAlchemy(www)
from flaskext.mail import Mail
mail = Mail(www)
from flaskext.bcrypt import Bcrypt
bcrypt = Bcrypt(www)
from www import tweaks
from www import main
from www import user
from www.menu import register
from werkzeug.utils import import_string
from flask.ext import admin
from flask.ext.admin.datastore.sqlalchemy import SQLAlchemyDatastore
'''
example config line:
WWW_BLUEPRINTS=[('www.blog',{'url_prefix': '/blog'}, ('blog', '/blog')),\
('www.contact',{'url_prefix': '/contact'}, ('contact', '/contact')]
'''
ASC = pymongo.ASCENDING
import flask
from functools import wraps
from base import app, getDBConnection
from flask import render_template, request, abort, Blueprint, url_for, make_response
from flaskext.login import login_required, login_user, current_user, logout_user
login_page = Blueprint("users", __name__, template_folder='templates')
import utils
logger = utils.make_logger(login_page)
import re
allowed_usernames = re.compile("^[a-zA-Z0-9._-]+$")
from flaskext.login import LoginManager
login_manager = LoginManager()
import pwdmanager
from pwdmanager import LmfdbUser, LmfdbAnonymousUser
# TODO update this url, needed for the user login token
base_url = "http://www.l-functions.org"
@login_manager.user_loader
def load_user(userid):
from pwdmanager import LmfdbUser
return LmfdbUser(userid)
login_manager.login_view = "users.info"
import hashlib
from flaskext.login import LoginManager
from model.models import User
login_manager = LoginManager()
login_manager.login_view = "login"
@login_manager.user_loader
def load_user(user_id):
"""Used by Flask-Login to get a user by its id."""
try:
ret = User.query.get(user_id)
ret.authenticated = True
except Exception as ex:
print type(ex)
print ex
ret = None
return ret
def check_login(username, password):
"""Checks whether or not the given username and password are valid."""
user = User.query.filter(User.username ==
username).first()
if user:
hasher = hashlib.sha1()
salt, pwd = user.password.split('$', 2)
hasher.update(salt + password)
if hasher.hexdigest() == pwd:
user.authenticated = True
name = u"Anonymous"
USERS = {1: User(u"Notch", 1), 2: User(u"Steve", 2), 3: User(u"Creeper", 3, False)}
USER_NAMES = dict((u.name, u) for u in USERS.itervalues())
app = Flask(__name__)
SECRET_KEY = "yeah, not actually a secret"
DEBUG = True
app.config.from_object(__name__)
login_manager = LoginManager()
login_manager.anonymous_user = Anonymous
login_manager.login_view = "login"
login_manager.login_message = u"Please log in to access this page."
login_manager.refresh_view = "reauth"
@login_manager.user_loader
def load_user(id):
return USERS.get(int(id))
login_manager.setup_app(app)
def lm_creation_and_setup(app):
lm = LoginManager()
lm.setup_app(app)
assert app.login_manager is lm
assert lm._load_user in app.before_request_funcs[None]
assert lm._update_remember_cookie in app.after_request_funcs[None]
def setup_logging(app):
log_file_path = app.config.get('LOG_FILE')
log_level = app.config.get('LOG_LEVEL', logging.WARN)
if log_file_path:
file_handler = RotatingFileHandler(log_file_path)
file_handler.setFormatter(
Formatter('%(name)s:%(levelname)s:[%(asctime)s] %(message)s '
'[in %(pathname)s:%(lineno)d]'))
file_handler.setLevel(log_level)
app.logger.addHandler(file_handler)
logger = logging.getLogger('pybossa')
logger.setLevel(log_level)
logger.addHandler(file_handler)
login_manager = LoginManager()
login_manager.login_view = 'account.signin'
login_manager.login_message = u"Please sign in to access this page."
app = create_app()
cache = Cache(config=app.config)
cache.init_app(app)
#toolbar = DebugToolbarExtension(app)
db = SQLAlchemy(app)
mail = Mail(app)
signer = URLSafeTimedSerializer(app.config['ITSDANGEORUSKEY'])
if app.config.get('SENTRY_DSN'):
sentr = Sentry(app)
# shut up useless SA warning:
import warnings;
warnings.filterwarnings('ignore', 'Unicode type received non-unicode bind param value.')
from sqlalchemy.exc import SAWarning
warnings.filterwarnings('ignore', category=SAWarning)
from migrate.versioning.util import construct_engine
from flask import Flask
from flaskext.login import LoginManager, current_user
from flaskext.sqlalchemy import SQLAlchemy
from grano import default_settings
app = Flask(__name__)
app.config.from_object(default_settings)
app.config.from_envvar('GRANO_SETTINGS', silent=True)
db = SQLAlchemy(app)
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.login_view = 'account.login'
# encoding=utf-8
from flask import g
from flaskext.login import LoginManager, AnonymousUser
from calepin.models import Blog
login_manager = LoginManager()
AnonymousUser.json = {}
login_manager.anonymous_user = AnonymousUser
login_manager.login_view = "frontend.site"
@login_manager.user_loader
def get_user(id):
return Blog.query.get(id)
from flaskext.login import LoginManager
from models import User
#flask-login
login_manager = LoginManager()
login_manager.login_view = "public.login"
#login
@login_manager.user_loader
def load_user(userid):
return User.query.get(userid)
ADMINS, 'error')
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
from logging.handlers import RotatingFileHandler
from logging import Formatter
def setup_logging(app):
log_file_path = app.config.get('LOG_FILE')
log_level = app.config.get('LOG_LEVEL', logging.WARN)
if log_file_path:
file_handler = RotatingFileHandler(log_file_path)
file_handler.setFormatter(Formatter(
'%(name)s:%(levelname)s:[%(asctime)s] %(message)s '
'[in %(pathname)s:%(lineno)d]'
))
file_handler.setLevel(log_level)
app.logger.addHandler(file_handler)
logger = logging.getLogger('pybossa')
logger.setLevel(log_level)
logger.addHandler(file_handler)
login_manager = LoginManager()
login_manager.login_view = 'account.signin'
login_manager.login_message = u"Please sign in to access this page."
app = create_app()
db = SQLAlchemy(app)
mail = Mail(app)
signer = URLSafeTimedSerializer(app.config['ITSDANGEORUSKEY'])
if app.config.get('SENTRY_DSN'):
sentr = Sentry(app)
from flask import (flash, redirect, request, render_template, url_for, abort,
jsonify)
from flaskext.markdown import Markdown
from flaskext.login import (LoginManager, login_required, login_user,
logout_user)
from flask_debugtoolbar import DebugToolbarExtension
from dagcuss import app
from dagcuss.forms import PostForm, RegistrationForm, LoginForm
from dagcuss.models import graph, element_to_model, Reply
from dagcuss import dynagraph
toolbar = DebugToolbarExtension(app)
md = Markdown(app)
login_manager = LoginManager()
login_manager.login_view = "login"
login_manager.setup_app(app)
@login_manager.user_loader
def load_user(username):
users = graph.users.index.lookup(username=username)
try:
return users.next()
except StopIteration:
return None
@app.errorhandler(404)
def page_not_found(e):
return render_template('404.html'), 404
import os from flaskext.login import LoginManager from flaskext.openid import OpenID from config import basedir lm = LoginManager() lm.setup_app(app) oid = OpenID(app, os.path.join(basedir, 'tmp'))
from local_model import *
import os
app = Flask(__name__)
SQLALCHEMY_DATABASE_URI = "sqlite:///" + os.path.join(os.path.dirname(__file__), "db", "database.db")
SECRET_KEY = "RandomSecretKey"
DEBUG = False
app.config.from_object(__name__)
db.init_app(app)
app.test_request_context().push()
db.create_all()
# set up the login manager
login_manager = LoginManager()
login_manager.login_view = "login"
login_manager.refresh_view = "reauth"
@login_manager.user_loader
def load_user(id):
return User.get_by_id(id)
@login_manager.token_loader
def load_token(token):
return User.get_by_token(token)
login_manager.setup_app(app)
# login
@app.route("/login", methods=["GET", "POST"])
def unauthorized_401(app):
lm = LoginManager()
lm.setup_app(app)
with raises(Unauthorized):
with assert_fired(user_unauthorized):
res = lm.unauthorized()
ADMINS = app.config.get('ADMINS', '')
if not app.debug and ADMINS:
mail_handler = SMTPHandler('127.0.0.1',
'*****@*****.**',
ADMINS, 'error')
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
from logging.handlers import RotatingFileHandler
from logging import Formatter
def setup_logging(app):
log_file_path = app.config.get('LOG_FILE')
log_level = app.config.get('LOG_LEVEL', logging.WARN)
if log_file_path:
file_handler = RotatingFileHandler(log_file_path)
file_handler.setFormatter(Formatter(
'%(name)s:%(levelname)s:[%(asctime)s] %(message)s '
'[in %(pathname)s:%(lineno)d]'
))
file_handler.setLevel(log_level)
app.logger.addHandler(file_handler)
logger = logging.getLogger('pybossa')
logger.setLevel(log_level)
logger.addHandler(file_handler)
login_manager = LoginManager()
login_manager.login_view = "/account/signin"
login_manager.login_message = u"Please sign in to access this page."
app = create_app()
if geometry is not None:
location = geometry.get('location')
return location
except:
logging.exception("problem geocoding location")
return None
def create_app():
return Flask(__name__)
app = create_app()
app.secret_key = str(uuid.uuid4())
login_manager = LoginManager()
login_manager.setup_app(app)
@login_manager.user_loader
def load_user(userid):
return HubUser.find(userid)
#load up some configuration settings
app.config.from_object('hubology.settings')
login_manager.login_view = "/sign-in"
login_manager.login_message = u"Please sign in to access hub-ology."
#Setup 404 handler
@app.errorhandler(404)
import setting
import sys
app = Flask(__name__)
app.config.from_object(setting)
app.debug = True
toolbar = DebugToolbarExtension(app)
mail = Mail(app)
babel = Babel(app)
cache = Cache(app)
#db = SQLAlchemy(app)
principals = Principal(app)
login_manager = LoginManager()
login_manager.setup_app(app)
userimage = UploadSet('userimage', IMAGES)
configure_uploads(app, (userimage))
# setting
# fix issue of unicode
reload(sys)
sys.setdefaultencoding("utf-8")
# fix issue of forerign_keys problem for SQLite
#db.session.execute('PRAGMA foreign_keys=ON;')
class SQLiteForeignKeysListener(PoolListener):
def connect(self, dbapi_con, con_record):
db_cursor = dbapi_con.execute('pragma foreign_keys=ON')
from flask import Flask
from flaskext.login import LoginManager
from flaskext.mail import Mail
from flask.ext.sqlalchemy import SQLAlchemy
from sqlalchemy.orm.exc import NoResultFound
from flask.ext.assets import Environment, Bundle
import logging
logging.basicConfig(level=logging.NOTSET)
app = Flask(__name__)
app.config.from_envvar('SETTINGS_FILE')
login_manager = LoginManager()
login_manager.setup_app(app, add_context_processor=True)
app.login_manager.login_view = 'login'
@app.context_processor
def utility_processor():
def format_price(amount, currency=u'\xa3', after=False):
amount = u'{0:.2f}'.format(amount)
if after:
return amount + currency
return currency + amount
def format_bankref(bankref):
return '%s-%s' % (bankref[:4], bankref[4:])
return dict(
format_price=format_price,
# Set up the application
from flask import Flask
from flaskext.login import LoginManager
import config
from accounts.models import UserAccount, Anonymous
app = Flask("bookout")
import urls
SECRET_KEY = "yeah, not actually a secret"
app.config.from_pyfile("config.py")
login_manager = LoginManager()
login_manager.anonymous_user = Anonymous
login_manager.login_view = "login"
login_manager.setup_app(app)
@login_manager.user_loader
def load_user(id):
return UserAccount.getuser(int(id))
import datetime
from bson.objectid import ObjectId
from flask import Flask, render_template, flash, redirect, request, session
from flaskext.login import LoginManager, login_required, login_user, logout_user
import settings
from db import users, Comic, User, Bookmark
from forms import LoginForm
from mongoengine import *
app = Flask(__name__)
app.secret_key = settings.SECRET_KEY
login_manager = LoginManager()
login_manager.login_view = "login"
login_manager.session_protection = None
login_manager.setup_app(app)
@login_manager.user_loader
def load_user(userid):
result = users.find_one({'_id': ObjectId(userid)})
if result:
user = User(result)
return user
#views
@app.route('/')
@login_required
from flask import *
from flask.views import MethodView
from flaskext.login import LoginManager, login_required, login_user, logout_user
from flask.ext.sqlalchemy import *
import ldap
from lib.ldapuser import LDAPUser
import json
from apps.addressbook.addressbook import addressbook
login_manager = LoginManager()
app = Flask(__name__)
app.debug = True
app.secret_key = 'foobar'
login_manager.setup_app(app)
login_manager.login_view = 'login'
#app.config.from_pyfile('test1.cfg')
#db = SQLAlchemy(app)
server = 'ldap://ford.fachschaft.cs.uni-kl.de'
l = ldap.initialize(server)
@login_manager.user_loader
def load_user(user_id):
user = LDAPUser(l, user_id)
if user.get_id:
return user
else:
from flask import (flash, redirect, request, render_template, url_for, abort,
jsonify)
from flaskext.markdown import Markdown
from flaskext.login import (LoginManager, login_required, login_user,
logout_user)
from flask_debugtoolbar import DebugToolbarExtension
from dagcuss import app
from dagcuss.forms import PostForm, RegistrationForm, LoginForm
from dagcuss.models import graph, element_to_model, Reply
from dagcuss import dynagraph
toolbar = DebugToolbarExtension(app)
md = Markdown(app)
login_manager = LoginManager()
login_manager.login_view = "login"
login_manager.setup_app(app)
@login_manager.user_loader
def load_user(username):
users = graph.users.index.lookup(username=username)
try:
return users.next()
except StopIteration:
return None
@app.errorhandler(404)
def page_not_found(e):
