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 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)
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(