def init_app(app):
security = Security()
security.init_app(app, user_datastore, login_form=LoginForm)
app.login_manager.request_loader(load_user_from_request)
app.login_manager.user_loader(load_user)
user_logged_out.connect(invalidate_user)
user_logged_in.connect(invalidate_user)
def test_user_logged_in_signal(self):
# Subscribe to signals for user login
signal_receiver = SignalReceiver()
user_logged_in.connect(signal_receiver.signal_user_receiver_function)
# Create a user.
with self.app.app_context():
User.create(
username = '******',
given_name = 'Randall',
surname = 'Degges',
email = '*****@*****.**',
password = '******',
)
# Attempt a login using username and password.
with self.app.test_client() as c:
resp = c.post('/login', data={
'login': '******',
'password': '******',
})
self.assertEqual(resp.status_code, 302)
# Check that signal for user login is received
self.assertEqual(len(signal_receiver.received_signals), 1)
received_signal = signal_receiver.received_signals[0]
# User instance is received
self.assertIsInstance(received_signal[1], User)
# Correct user instance is received
logged_in_user = received_signal[1]
self.assertEqual(logged_in_user.email, '*****@*****.**')
self.assertEqual(logged_in_user.surname, 'Degges')
def test_user_logged_in_signal(self):
# Subscribe to signals for user login
signal_receiver = SignalReceiver()
user_logged_in.connect(signal_receiver.signal_user_receiver_function)
# Create a user.
with self.app.app_context():
User.create(
username='******',
given_name='Randall',
surname='Degges',
email='*****@*****.**',
password='******',
)
# Attempt a login using username and password.
with self.app.test_client() as c:
resp = c.post('/login',
data={
'login': '******',
'password': '******',
})
self.assertEqual(resp.status_code, 302)
# Check that signal for user login is received
self.assertEqual(len(signal_receiver.received_signals), 1)
received_signal = signal_receiver.received_signals[0]
# User instance is received
self.assertIsInstance(received_signal[1], User)
# Correct user instance is received
logged_in_user = received_signal[1]
self.assertEqual(logged_in_user.email, '*****@*****.**')
self.assertEqual(logged_in_user.surname, 'Degges')
def setup_login_manager(app):
"""
Configure the LoginManager for the provided app.
"""
login_manager = LoginManager()
login_manager.login_view = 'auth.login_user'
login_manager.login_message = 'Resource access not authorized.'
login_manager.login_message_category = 'error'
login_manager.anonymous_user = AnonymousUser
login_manager.init_app(app)
login_manager.user_loader(load_user)
user_logged_in.connect(on_login, app)
def init_app(app):
login_manager.init_app(app)
# provide a landing page that asks the user to login
app.route('/login_request')(login_request)
# flash notify on login and logout
user_logged_in.connect(logged_in, app)
# see https://github.com/maxcountryman/flask-login/issues/162
user_logged_out.connect(logged_out, app)
_init_mod(app, 'RELENGAPI_AUTHENTICATION', 'browserid', 'relengapi.lib.auth.auth_types')
_init_mod(app, 'RELENGAPI_PERMISSIONS', 'static', 'relengapi.lib.auth.perms_types')
def initialize(self): def logOutHandler(sender, **kwargs): self.onLogout() def logInHandler(sender, **kwargs): for key, value in kwargs.iteritems(): if isinstance(value, SessionUser): self.onLogin() self.logOutHandler = logOutHandler self.logInHandler = logInHandler user_logged_in.connect(logInHandler) user_logged_out.connect(logOutHandler)
def init_app(app):
login_manager.init_app(app)
# provide a landing page that asks the user to login
app.route('/login_request')(login_request)
# flash notify on login and logout
user_logged_in.connect(logged_in, app)
# see https://github.com/maxcountryman/flask-login/issues/162
user_logged_out.connect(logged_out, app)
_init_mod(app, 'RELENGAPI_AUTHENTICATION', 'browserid',
'relengapi.lib.auth.auth_types')
_init_mod(app, 'RELENGAPI_PERMISSIONS', 'static',
'relengapi.lib.auth.perms_types')
def setup_authentication(app):
login_manager.init_app(app)
login_manager.anonymous_user = models.AnonymousUser
app.secret_key = settings.COOKIE_SECRET
app.register_blueprint(google_oauth.blueprint)
app.register_blueprint(saml_auth.blueprint)
user_logged_in.connect(log_user_logged_in)
if settings.AUTH_TYPE == 'hmac':
login_manager.request_loader(hmac_load_user_from_request)
elif settings.AUTH_TYPE == 'api_key':
login_manager.request_loader(api_key_load_user_from_request)
else:
logger.warning("Unknown authentication type ({}). Using default (HMAC).".format(settings.AUTH_TYPE))
login_manager.request_loader(hmac_load_user_from_request)
def init_app(app):
login_manager.init_app(app)
# provide a landing page that asks the user to login
app.route('/login_request')(login_request)
# flash notify on login and logout
user_logged_in.connect(logged_in, app)
# see https://github.com/maxcountryman/flask-login/issues/162
user_logged_out.connect(logged_out, app)
auth_type = app.config.get('RELENGAPI_AUTHENTICATION',
{}).get('type', 'browserid')
app.config['RELENGAPI_AUTHENTICATION_TYPE'] = auth_type
# load and initialize the appropriate auth mechanism. Using entry_points
# like this avoids even importing plugins this app isn't using
entry_points = list(
pkg_resources.iter_entry_points('relengapi.auth.mechanisms',
auth_type))
if len(entry_points) == 0:
raise RuntimeError("no such authentication type %r" % (auth_type, ))
elif len(entry_points) > 1: # pragma: no cover
raise RuntimeError(
"multiple authentication plugins defined for type %r" %
(auth_type, ))
ep = entry_points[0]
plugin_init_app = ep.load()
plugin_init_app(app)
perms_type = app.config.get('RELENGAPI_PERMISSIONS',
{}).get('type', 'static')
app.config['RELENGAPI_PERMISSIONS_TYPE'] = perms_type
# now load and initialize the appropriate perms mechanism
entry_points = list(
pkg_resources.iter_entry_points('relengapi.perms.mechanisms',
perms_type))
if len(entry_points) == 0:
raise RuntimeError("no such permissions type %r" % (perms_type, ))
elif len(entry_points) > 1: # pragma: no cover
raise RuntimeError("multiple permissions plugins defined for type %r" %
(perms_type, ))
ep = entry_points[0]
plugin_init_app = ep.load()
plugin_init_app(app)
def init_app(app):
login_manager.init_app(app)
# provide a landing page that asks the user to login
app.route('/login_request')(login_request)
# flash notify on login and logout
user_logged_in.connect(logged_in, app)
# see https://github.com/maxcountryman/flask-login/issues/162
user_logged_out.connect(logged_out, app)
auth_type = app.config.get(
'RELENGAPI_AUTHENTICATION', {}).get('type', 'browserid')
app.config['RELENGAPI_AUTHENTICATION_TYPE'] = auth_type
# load and initialize the appropriate auth mechanism. Using entry_points
# like this avoids even importing plugins this app isn't using
entry_points = list(
pkg_resources.iter_entry_points('relengapi.auth.mechanisms', auth_type))
if len(entry_points) == 0:
raise RuntimeError("no such authentication type %r" % (auth_type,))
elif len(entry_points) > 1:
raise RuntimeError(
"multiple authentication plugins defined for type %r" % (auth_type,))
ep = entry_points[0]
plugin_init_app = ep.load()
plugin_init_app(app)
perms_type = app.config.get(
'RELENGAPI_PERMISSIONS', {}).get('type', 'static')
app.config['RELENGAPI_PERMISSIONS_TYPE'] = perms_type
# now load and initialize the appropriate perms mechanism
entry_points = list(
pkg_resources.iter_entry_points('relengapi.perms.mechanisms', perms_type))
if len(entry_points) == 0:
raise RuntimeError("no such permissions type %r" % (perms_type,))
elif len(entry_points) > 1:
raise RuntimeError(
"multiple permissions plugins defined for type %r" % (perms_type,))
ep = entry_points[0]
plugin_init_app = ep.load()
plugin_init_app(app)
def create_app(config='planlos.config.Config'):
app = Flask('planlos')
app.config.from_object(config)
db.init_app(app)
mail.init_app(app)
flask_sijax.Sijax(app)
# Flask Login
login_manager.setup_app(app)
app.register_blueprint(base, url_prefix='/')
app.register_blueprint(admin, url_prefix='/admin')
app.register_blueprint(calendar, url_prefix='/events')
app.register_blueprint(accounts, url_prefix='/users')
app.register_blueprint(locations, url_prefix='/locations')
app.register_blueprint(webservice, url_prefix='/webservice')
app.register_blueprint(groups, url_prefix='/groups')
app.jinja_env.globals['widget'] = widget
user_logged_in.connect(set_login_stamp, app)
return app
def initialize(self):
self.user = None
self.designs = None
self.astroprintCloud = None
self.cameraManager = None
self.materialCounter = None
self._printerListener = None
def logOutHandler(sender, **kwargs):
self.onLogout()
def logInHandler(sender, **kwargs):
for key, value in kwargs.iteritems():
if isinstance(value, SessionUser):
self.onLogin()
self.logOutHandler = logOutHandler
self.logInHandler = logInHandler
user_logged_in.connect(logInHandler)
user_logged_out.connect(logOutHandler)
def create_app(testing=False, database=db, config_env='INKMONKWEB_CONFIG',
instance_path=None, initialize_blueprints=True):
if instance_path:
app = FlaskPlus(__name__, instance_path=instance_path,
instance_relative_config=True)
else:
app = FlaskPlus(__name__)
app.config.from_object('inkmonkweb.default_config')
app.config.from_envvar(config_env)
if testing:
app.config['TESTING'] = True
app.config['WTF_CSRF_ENABLED'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = app.config['TESTDB_URI']
app.config['LOG_FILE_LOC'] = app.config['TESTLOG_LOC']
app.errorhandler(500)(internal_server_error)
# app.before_request(geo_redirect)
# app.errorhandler(400)(exception_response_json)
database.init_app(app)
listener.init_app(app)
assets_env.init_app(app)
mailer.init_app(app)
if not app.config['TESTING']:
# standalone_pages_bp.before_request(geo_redirect)
# dashboard_bp.before_request(geo_redirect)
# app_bp.before_request(geo_redirect)
csrf.init_app(app)
KVSessionExtension(redis_store, app)
# Session(app)
user_logged_in.connect(session_transition_handler, app)
# Register Jinja2 Custom filters
app.jinja_env.filters['timestampize'] = template_filters.timestampize
app.jinja_env.filters['hash_hmac'] = template_filters.hash_hmac
app.jinja_env.filters['json'] = template_filters.json_dumps
app.jinja_env.filters['todict'] = template_filters.todict
app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension')
app.jinja_env.hamlish_enable_div_shortcut = True
app.jinja_env.line_statement_prefix = '%'
applogger = AppLogHandler(app)
applogger.start()
security.init_app(
app, user_datastore,
register_form=forms.ExtendedRegisterForm,
confirm_register_form=forms.ExtendedRegisterForm)
# security_state.login_context_processor(security_login_processor)
fedex.init_app(app)
# app.wsgi_app = HTTPMethodOverrideMiddleware(app.wsgi_app)
if initialize_blueprints:
admin = create_admin()
admin.init_app(app)
app.register_blueprint(standalone_pages_bp)
app.register_blueprint(store_bp, url_prefix='/store')
app.register_blueprint(app_bp, url_prefix='/app')
app.register_blueprint(market_bp, url_prefix='/market')
app.register_blueprint(
create_api_bp(), url_prefix='/json')
app.register_blueprint(
create_api_bp(name='api',
authenticator=with_basic_authentication,
optional_authenticator=with_basic_authentication),
subdomain='api', url_prefix='/v1')
# app.register_blueprint(
# create_api_bp('testapi', with_basic_authentication),
# url_prefix='/test/api/v1')
app.register_blueprint(dashboard_bp, url_prefix='/dashboard')
for integration in integrations:
integration.register(app)
app.register_blueprint(hooks_bp, url_prefix='/hooks')
app.blueprints['adminapi'].errorhandler(400)(exception_response_json)
return app
# signals
def saveLoginEvent(app, user):
#FIXME use real IP in production
#ip = request.remote_addr
ip = getRandomIP()
login = Login(userID=user.userID, ip=ip)
match = geoip.geolite2.lookup(ip)
if match:
country = Country.query.filter_by(code=match.country).first()
if country:
login.countryID = country.countryID
if match.location:
login.latitude, login.longitude = match.location
db.session.add(login)
db.session.commit()
user_logged_in.connect(saveLoginEvent)
if __name__ == "__main__":
app.run()
toolbar = DebugToolbarExtension(app)
db = SQLAlchemy(app)
app.csrf = CsrfProtect(app)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'home.signin'
babel = Babel(app)
@babel.localeselector
def get_locale():
return request.accept_languages.best_match(app.config['LANGUAGES'].keys())
def log_login(app,user):
'''update the last login time of the user'''
user.last_login_time = datetime.utcnow()
db.session.commit()
user_logged_in.connect(log_login)
user_loaded_from_cookie.connect(log_login)
from app.views import *
app.register_blueprint(home,url_prefix='')
app.register_blueprint(course,url_prefix='/course')
app.register_blueprint(review, url_prefix='/review')
app.register_blueprint(api, url_prefix='/api')
app.register_blueprint(user, url_prefix='/user')
app.register_blueprint(teacher, url_prefix='/teacher')
@app.before_request
def before_request():
g.user = current_user
@app.route('/')
def index():
return render_template('index.html')
def handle_login(app, user):
g.user.last_last_login = g.user.last_login
g.user.last_login = datetime.utcnow()
db.session.add(g.user)
db.session.commit()
user_logged_in.connect(handle_login)
@app.route('/login', methods=['GET', 'POST'])
def login():
if g.user is not None and g.user.is_authenticated():
return redirect(url_for('index'))
login_form = LoginForm()
if login_form.validate_on_submit():
user = User.query.filter_by(email = login_form.email.data).first()
login_user(user)
return redirect(request.args.get("next") or url_for("index"))
else:
return render_template('login.html', form = login_form)
def setup_event_handlers():
from flask.ext.login import user_logged_in, user_login_confirmed
from app.event_handlers import on_user_logged_in, on_user_login_confirmed
user_logged_in.connect(on_user_logged_in)
user_login_confirmed.connect(on_user_login_confirmed)
# Logging
#
def log_session_start(app, user):
session = LoginSession.new()
db.session.add(session)
db.session.commit()
def log_session_end(app, user):
session = LoginSession.query.get_active_for(user)
if session:
session.ended_at = datetime.utcnow()
db.session.commit()
user_logged_in.connect(log_session_start)
user_logged_out.connect(log_session_end)
# login redirect utilities
# from http://flask.pocoo.org/snippets/62/
def is_safe_url(target):
ref_url = urlparse(request.host_url)
test_url = urlparse(urljoin(request.host_url, target))
return test_url.scheme in ('http', 'https') and \
ref_url.netloc == test_url.netloc
def get_redirect_target():
for target in (request.values.get('next'), request.referrer):
if not target:
# Token is not valid if last_login_date has changed
if user and safe_str_cmp(
user.last_login_date.isoformat(), user_last_login_date
):
return user
return None
@classmethod
def from_auth_token_perm(cls, token):
""" Recovers a user from a non-expiring auth token
Use with :meth:`gen_auth_token_perm`
"""
return cls.from_auth_token(
token, serializer=auth_token_serializer_perm,
)
@classmethod
def update_last_login_date(cls, app, user):
new_login_date = datetime.datetime.utcnow()
cls.query.filter_by(id=user.id).update({
'last_login_date': new_login_date,
})
db.session.commit()
user_logged_in.connect(User.update_last_login_date)
def setup_event_handlers():
from flask.ext.login import user_logged_in, user_login_confirmed
from app.event_handlers import on_user_logged_in, on_user_login_confirmed
user_logged_in.connect(on_user_logged_in)
user_login_confirmed.connect(on_user_login_confirmed)
# signals def saveLoginEvent(app, user): #FIXME use real IP in production #ip = request.remote_addr ip = getRandomIP() login = Login(userID=user.userID, ip=ip) match = geoip.geolite2.lookup(ip) if match: country = Country.query.filter_by(code=match.country).first() if country: login.countryID = country.countryID if match.location: login.latitude, login.longitude = match.location db.session.add(login) db.session.commit() user_logged_in.connect(saveLoginEvent) if __name__ == "__main__": app.run()
db = SQLAlchemy(app)
app.csrf = CsrfProtect(app)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'home.signin'
babel = Babel(app)
@babel.localeselector
def get_locale():
return request.accept_languages.best_match(app.config['LANGUAGES'].keys())
def log_login(app, user):
'''update the last login time of the user'''
user.last_login_time = datetime.utcnow()
db.session.commit()
user_logged_in.connect(log_login)
user_loaded_from_cookie.connect(log_login)
from app.views import *
app.register_blueprint(home, url_prefix='')
app.register_blueprint(course, url_prefix='/course')
app.register_blueprint(review, url_prefix='/review')
app.register_blueprint(api, url_prefix='/api')
app.register_blueprint(user, url_prefix='/user')
app.register_blueprint(teacher, url_prefix='/teacher')
from datetime import datetime
import logging
from flask.ext.login import user_logged_in
from apps import db, app
def user_logged_in_callback(app, user, **extra):
logging.info("user logged in receiver")
logging.info(user)
if user.is_authenticated():
user.date_last_logged_in = datetime.utcnow()
db.session.add(user)
db.session.commit()
user_logged_in.connect(user_logged_in_callback, app)
def init_signals(app):
user_logged_in.connect(on_user_logged_in, app)
user_logged_out.connect(on_user_logged_out, app)
voucher_generated.connect(on_voucher_generated, app)
voucher_logged_in.connect(on_voucher_logged_in, app)
from datetime import date, datetime
from werkzeug.security import generate_password_hash
from flask.ext.login import user_logged_in, user_logged_out
from .util import *
def when_user_logged_in(sender, user, **extra):
session['shipper_or_deliverer'] = 1 if hasattr(user, 'sid') else 2
# print "user_logged_in, %s" % session['shipper_or_deliverer']
session.modified = True
def when_user_logged_out(sender, user, **extra):
del session['shipper_or_deliverer']
session.modified = True
user_logged_in.connect(when_user_logged_in, app)
user_logged_out.connect(when_user_logged_out, app)
@lm.user_loader
def load_user(user_id):
if session.get('shipper_or_deliverer') == 1:
return Shipper.query.get(int(user_id))
elif session.get('shipper_or_deliverer') == 2:
return Deliverer.query.get(int(user_id))
else:
return None
def sendmail(title, body, recipients):
ses.send_email(
