def create_app(): app = Flask(__name__) app.config['SECRET_KEY'] = '9OLWxND4o83j4K4iuopO' #app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db/db.sqlite' app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite' #with app.app_context(): db.init_app(app) login_manager = LoginManager() login_manager.login_view = 'auth.login' login_manager.init_app(app) login_manager.anonymous_user = Anonymous from .models import User @login_manager.user_loader def load_user(user_id): # since the user_id is just the primary key of our user table, use it in the query for the user return User.query.get(int(user_id)) # blueprint for auth routes in our app from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint) # blueprint for non-auth parts of app from .main import main as main_blueprint app.register_blueprint(main_blueprint) app.app_context().push() return app
def create_app(config: Config): app = Flask(__name__, instance_path=config.server.instance_path) app.config.from_object(config.server) loglevel = getattr(logging, config.project.loglevel.upper()) app.logger.setLevel(loglevel) db.init_app(app) cache.init_app(app, config) login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = "/login" login_manager.anonymous_user = AnonymousUser login_manager.session_protection = "strong" @login_manager.user_loader def load_user(userid: str): return UserService().get(userid) @app.route("/logout") @login_required def logout(): logout_user() return redirect("/login") init_dash(app, config) return app
def test_index_page(): file_path = find_dotenv('.env.test', usecwd=True) load_dotenv(file_path, override=True) database_config = DatabaseConfig() auth_config = AuthConfig() flask_config = FlaskConfig() mocked_client = mongomock.MongoClient() mock_db = mocked_client.get_database(database_config.db_name) client = AtlasClient(database_config, mocked_client) login_manager = LoginManager() login_manager.anonymous_user = TestUser #Create the new app. test_app = create_app(client, auth_config, login_manager) test_app.config.from_object(flask_config) test_app.config['LOGIN_DISABLED'] = True mock_item_response = ToDoItem.new_item_as_dict( "Hello form the integration tests") mock_db.get_collection("test_collection_name").insert_one( mock_item_response) response = test_app.test_client().get("/") assert 200 == response.status_code assert "Hello form the integration tests" in response.data.decode()
def test_app(): # construct the new application try: file_path = find_dotenv('.env') load_dotenv(file_path, override=True) except: print("Could not find .env") database_config = DatabaseConfig() auth_config = AuthConfig() flask_config = FlaskConfig() database_config._todo_collection_name = os.environ.get('TEST_COLLECTION') mongo_client = MongoClient(database_config.db_url) client = AtlasClient(database_config, mongo_client) client._collection.delete_many({}) login_manager = LoginManager() login_manager.anonymous_user = TestUser application = create_app(client, auth_config, login_manager) application.config.from_object(flask_config) application.config['LOGIN_DISABLED'] = True # start the app in its own thread. thread = Thread(target=lambda: application.run(use_reloader=False)) thread.daemon = True thread.start() yield application # Tear Down thread.join(1)
def register_login(app): login_manager = LoginManager() login_manager.login_view = "auth.login" login_manager.session_protection = "strong" login_manager.login_message = u"这个页面要求登陆,请登陆" login_manager.anonymous_user = Anonymous login_manager.init_app(app) return login_manager
def init_login_manager(app): login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = 'auth.login' login_manager.login_message = 'Для доступа к данной странице нужно аутенцифицироваться' login_manager.login_message_category = 'warning' login_manager.user_loader(load_user) login_manager.anonymous_user = Anonymous
def configure_login(app): login_manager = LoginManager() login_manager.session_protection = 'strong' login_manager.login_view = 'user.login' login_manager.login_message = '请先登录' login_manager.anonymous_user = Anonymous login_manager.init_app(app) @login_manager.user_loader def load_user(user_id): return User.query.get(int(user_id))
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 get_login_manager(root: RootConfigDirectoryContext) -> LoginManager: """ Creates a login manager """ login_manager = LoginManager() login_manager.login_view = 'auth.login' login_manager.anonymous_user = AnonymousUserModel @login_manager.user_loader def load_user(uid): return current_app.config['model_factory'].user(str(uid)) return login_manager
def init_login_manager(): login_manager = LoginManager() login_manager.session_protection = 'strong' login_manager.login_view = 'auth.login' from dnsdb_common.dal.models.user import User, AnonymousUser login_manager.anonymous_user = AnonymousUser @login_manager.user_loader def load_user(user_id): return User.query.get(int(user_id)) return login_manager
def configure_auth(app): login_manager = LoginManager() login_manager.init_app(app) class AnonymousUser(AnonymousUserMixin): def to_dict(self): return {"anonynous": True} login_manager.anonymous_user = AnonymousUser @login_manager.user_loader def load_user(user_id): return auth.load_user(user_id)
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
def setup_app(app): """Setup login extension.""" app.config.setdefault('CFG_OPENID_AUTHENTICATION', False) app.config.setdefault('CFG_OAUTH1_AUTHENTICATION', False) app.config.setdefault('CFG_OAUTH2_AUTHENTICATION', False) @app.errorhandler(401) def do_login_first(error=401): """Display login page when user is not authorised.""" if request.is_xhr: return g._("Authorization failure"), 401 secure_url = url_for(request.endpoint, _external=True, _scheme='https', **request.view_args) if not urllib.unquote(secure_url).startswith(request.base_url): return redirect(secure_url) if current_user.is_guest: if not session.get('_flashes'): flash(g._("Please sign in to continue."), 'info') from invenio_accounts.views.accounts import login return login(referer=request.url) else: from flask import render_template return render_template("401.html"), 401 # Let's create login manager. _login_manager = LoginManager(app) _login_manager.login_view = app.config.get('CFG_LOGIN_VIEW', 'webaccount.login') _login_manager.anonymous_user = UserInfo _login_manager.unauthorized_handler(do_login_first) @user_logged_in.connect_via(app) def _logged_in(sender, user): """Update last login date.""" from invenio_accounts.models import User User.query.filter_by(id=user.get_id()).update( dict(last_login=datetime.now())) @_login_manager.user_loader def _load_user(uid): """Do not raise an exception if uid is not valid or missing.""" return UserInfo(int(uid)) return app
def setup_authorization(app, CFG): # User session management setup # https://flask-login.readthedocs.io/en/latest login_manager = LoginManager() login_manager.init_app(app) login_manager.anonymous_user = Guest_Info # Flask-Login helper to retrieve a user from our db @login_manager.user_loader def load_user(user_id): return User_Info.get(user_id) setup_general_authorization(app, CFG) if CFG["Server"]["Debug"]: setup_debug_authorization(app, CFG) setup_google_authorization(app, CFG)
def setup_app(app): """Setup login extension.""" app.config.setdefault('CFG_OPENID_AUTHENTICATION', False) app.config.setdefault('CFG_OAUTH1_AUTHENTICATION', False) app.config.setdefault('CFG_OAUTH2_AUTHENTICATION', False) @app.errorhandler(401) def do_login_first(error=401): """Display login page when user is not authorised.""" if request.is_xhr: return g._("Authorization failure"), 401 secure_url = url_for(request.endpoint, _external=True, _scheme='https', **request.view_args) if not urllib.unquote(secure_url).startswith(request.base_url): return redirect(secure_url) if current_user.is_guest: if not session.get('_flashes'): flash(g._("Please sign in to continue."), 'info') from invenio_accounts.views.accounts import login return login(referer=request.url) else: from flask import render_template return render_template("401.html"), 401 # Let's create login manager. _login_manager = LoginManager(app) _login_manager.login_view = app.config.get('CFG_LOGIN_VIEW', 'webaccount.login') _login_manager.anonymous_user = UserInfo _login_manager.unauthorized_handler(do_login_first) @user_logged_in.connect_via(app) def _logged_in(sender, user): """Update last login date.""" from invenio_accounts.models import User User.query.filter_by(id=user.get_id()).update(dict( last_login=datetime.now() )) @_login_manager.user_loader def _load_user(uid): """Do not raise an exception if uid is not valid or missing.""" return UserInfo(int(uid)) return app
def _get_login_manager(app, anonymous_user): lm = LoginManager() lm.anonymous_user = anonymous_user or AnonymousUser lm.localize_callback = localize_callback lm.login_view = "%s.login" % cv("BLUEPRINT_NAME", app=app) lm.user_loader(_user_loader) lm.request_loader(_request_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
def init_app(app): login_manager = LoginManager(app) login_manager.anonymous_user = models.AnonymousUser ldap_manager = LDAP3LoginManager(app) @ldap_manager.save_user def save_user(dn, username, data, memberships): user = models.User.get(username) return user @login_manager.user_loader def load_user(id): return models.User.get(id) # Set up sanity checks. from . import sanity getattr(app, 'sanity_check_modules', []).append(sanity)
def login_manager_factory(state): """ Create a login manager accordingly. """ login_manager = LoginManager() login_manager.login_view = 'security.login' login_manager.login_message_category = "warning" # Set custom anonymous user to return the user which is running the # process. def make_anon_user(): return _AnonymousUserMixin() login_manager.anonymous_user = make_anon_user @login_manager.user_loader def load_user(user_id): return security_services.get_user(user_id) return login_manager
def _get_login_manager( self, app: FlaskUnchained, anonymous_user: AnonymousUser, ) -> LoginManager: """ Get an initialized instance of Flask Login's :class:`~flask_login.LoginManager`. """ login_manager = LoginManager() login_manager.anonymous_user = anonymous_user or AnonymousUser login_manager.localize_callback = _ login_manager.request_loader(self._request_loader) login_manager.user_loader( lambda *a, **kw: self.security_utils_service.user_loader(*a, **kw)) login_manager.login_view = 'security_controller.login' login_manager.login_message = _( 'flask_unchained.bundles.security:error.login_required') login_manager.login_message_category = 'info' login_manager.needs_refresh_message = _( 'flask_unchained.bundles.security:error.fresh_login_required') login_manager.needs_refresh_message_category = 'info' login_manager.init_app(app) return login_manager
def register_routes(app): """Register app routes.""" def _user_loader(user_id=None, flush_cached=False): return UserSession(user_id, flush_cached) login_manager = LoginManager() login_manager.init_app(app) login_manager.user_loader(_user_loader) login_manager.anonymous_user = _user_loader # Register API routes. import boac.api.admin_controller import boac.api.alerts_controller import boac.api.auth_controller import boac.api.cohort_controller import boac.api.config_controller import boac.api.course_controller import boac.api.curated_group_controller import boac.api.notes_controller import boac.api.search_controller import boac.api.student_controller import boac.api.status_controller import boac.api.user_controller # Register error handlers. import boac.api.error_handlers index_html = open(app.config['INDEX_HTML']).read() @app.login_manager.unauthorized_handler def unauthorized_handler(): return jsonify(success=False, data={'login_required': True}, message='Unauthorized'), 401 # Unmatched API routes return a 404. @app.route('/api/<path:path>') def handle_unmatched_api_route(**kwargs): app.logger.error('The requested resource could not be found.') raise boac.api.errors.ResourceNotFoundError( 'The requested resource could not be found.') # Non-API routes are handled by the front end. @app.route('/', defaults={'path': ''}) @app.route('/<path:path>') def front_end_route(**kwargs): vue_base_url = app.config['VUE_LOCALHOST_BASE_URL'] return redirect(vue_base_url + request.full_path) if vue_base_url else make_response( index_html) @app.before_request def before_request(): session.permanent = True app.permanent_session_lifetime = datetime.timedelta( minutes=app.config['INACTIVE_SESSION_LIFETIME']) session.modified = True @app.after_request def after_api_request(response): if app.config['BOAC_ENV'] == 'development': # In development the response can be shared with requesting code from any local origin. response.headers['Access-Control-Allow-Headers'] = 'Content-Type' response.headers['Access-Control-Allow-Origin'] = app.config[ 'VUE_LOCALHOST_BASE_URL'] response.headers['Access-Control-Allow-Credentials'] = 'true' response.headers[ 'Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS, PUT, DELETE' if request.full_path.startswith('/api'): log_message = ' '.join([ request.remote_addr, request.method, request.full_path, response.status, ]) if response.status_code >= 500: app.logger.error(log_message) elif response.status_code >= 400: app.logger.warning(log_message) else: app.logger.debug(log_message) return response
from flask import Flask from flask_sqlalchemy import SQLAlchemy, BaseQuery from sqlalchemy import create_engine from sqlalchemy.orm import scoped_session, sessionmaker from sqlalchemy.ext.declarative import declarative_base from flask_login import LoginManager from app.mixins import GuestUserMixin app = Flask(__name__) app.config.from_object('config') engine = create_engine(app.config['SQLALCHEMY_DATABASE_URI']) db_scoped_session = scoped_session(sessionmaker(bind=engine)) Base = declarative_base() Base.query = db_scoped_session.query_property(query_cls=BaseQuery) db = SQLAlchemy(app) db.session = db_scoped_session db.Model = Base login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = 'login' login_manager.anonymous_user = GuestUserMixin from app import views, models
def load_user(session_token): try: return User.objects.get(session_token=session_token) except DoesNotExist: return None @login_manager.request_loader def api_auth(request): try: return User.objects.get(api_key=request.headers.get('X-Api-Key')) except DoesNotExist: return None login_manager.anonymous_user = auth_module.get_default_user @frontend.before_request def frontend_login_required(): if not current_user.is_active and (request.endpoint and request.endpoint != 'frontend.static'): return login_manager.unauthorized() @api.before_request def api_login_required(): if not current_user.is_active and not request.method == "OPTIONS": return dumps({"error": "X-Api-Key header missing or invalid"}), 401
logger = make_logger(login_page) login_manager = LoginManager() from .pwdmanager import userdb, SeminarsUser, SeminarsAnonymousUser @login_manager.user_loader def load_user(uid): return SeminarsUser(uid) login_manager.login_view = "user.info" login_manager.anonymous_user = SeminarsAnonymousUser def get_username(uid): """returns the name of user @uid""" return SeminarsUser(uid).name # globally define user properties and username @app.context_processor def ctx_proc_userdata(): userdata = { "user": current_user, "usertime": datetime.now(tz=current_user.tz), } # used to display name of locks
app = Flask(__name__, template_folder='../templates') app.jinja_env.filters['first_paragraphs'] = first_paragraphs app.secret_key = _cfg("secret-key") app.jinja_env.cache = None app.json_encoder = CustomJSONEncoder markdown = Markdown(app, safe_mode='remove', extensions=[KerbDown()]) login_manager = LoginManager() login_manager.init_app(app) @login_manager.user_loader def load_user(username: str) -> User: return User.query.filter(User.username == username).first() login_manager.anonymous_user = lambda: None app.register_blueprint(profiles) app.register_blueprint(accounts) app.register_blueprint(login_oauth) app.register_blueprint(anonymous) app.register_blueprint(blog) app.register_blueprint(admin) app.register_blueprint(mods) app.register_blueprint(lists) app.register_blueprint(api) try: locale.setlocale(locale.LC_ALL, 'en_US') except: try:
self.last_seen = datetime.utcnow() db.session.add(self) def __repr__(self): return '<User %r>' % self.username class AnonymousUser(AnonymousUserMixin): def can(self, permissions): return False def is_administrator(self): return False login_manager.anonymous_user = AnonymousUser # Flask_login requires a callback to load a user using the given identifier @login_manager.user_loader def load_user(user_id): return User.query.get(int(user_id)) class Transaction(db.Model): __tablename__ = 'transactions' transaction_id = db.Column(db.Integer, autoincrement=True, primary_key=True) user = db.Column(db.Integer, db.ForeignKey('users.id')) block = db.Column(db.String(256), unique=True)
from flask_login import AnonymousUserMixin class BlogAnonymous(AnonymousUserMixin): def __init__(self): self.username = '******' bcrypt = Bcrypt() oid = OpenID() login_manager = LoginManager() login_manager.login_view = "auth.login" login_manager.session_protection = "strong" login_manager.login_message = "Please login to access this page" login_manager.login_message_category = "info" login_manager.anonymous_user = BlogAnonymous def create_module(app, **kwargs): bcrypt.init_app(app) oid.init_app(app) login_manager.init_app(app) twitter_blueprint = make_twitter_blueprint( api_key=app.config.get("TWITTER_API_KEY"), api_secret=app.config.get("TWITTER_API_SECRET"), ) app.register_blueprint(twitter_blueprint, url_prefix="/auth/login") facebook_blueprint = make_facebook_blueprint( client_id=app.config.get("FACEBOOK_CLIENT_ID"),
# Flask app init from flask import Flask app = Flask(__name__) app.config.from_object('config') # TODO SSL Stuff # import ssl # ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2) # ssl_context.load_cert_chain('certs/homeberry.pem', 'certs/homeberry.key') # Flask-SQLAlchemy stuff from flask_sqlalchemy import SQLAlchemy db = SQLAlchemy(app) # Flask-Login stuff from flask_login import LoginManager from app.auth.models import HomeberryAnonymousUser lm = LoginManager() lm.init_app(app) lm.anonymous_user = HomeberryAnonymousUser # PlayerManager and MPDClient from app.music.players import PlayerManager pm = PlayerManager() from app.auth import models, views from app.music import models, views
LOGIN_MANAGER = LoginManager(app) LOGIN_MANAGER.login_view = "login" class Anonymous(AnonymousUserMixin): """Class for providing guest sessions in app. """ def __init__(self): self.username = u'GUEST' self.role = 'user' self.uid = 2 def __repr__(self): return unicode(self.username) LOGIN_MANAGER.anonymous_user = Anonymous class User(UserMixin): """Class which describes User entity.""" def __init__(self, uid, first_name, last_name, email, password, role, avatar=None): self.uid = uid self.first_name = first_name self.last_name = last_name self.email = email self.password = password self.role = role self.avatar = avatar
mimetypes.add_type('application/mp4', '.m4a') mimetypes.add_type('application/mp4', '.m4b') mimetypes.add_type('application/ogg', '.ogg') mimetypes.add_type('application/ogg', '.oga') app = Flask(__name__) app.config.update( SESSION_COOKIE_HTTPONLY=True, SESSION_COOKIE_SAMESITE='Lax', REMEMBER_COOKIE_SAMESITE='Lax', # will be available in flask-login 0.5.1 earliest ) lm = LoginManager() lm.login_view = 'web.login' lm.anonymous_user = ub.Anonymous lm.session_protection = 'strong' ub.init_db(cli.settingspath) # pylint: disable=no-member config = config_sql.load_configuration(ub.session) web_server = WebServer() babel = Babel() _BABEL_TRANSLATIONS = set() log = logger.create() from . import services
self.is_admin = False def __bool__(self): return False LOGIN_MANAGER = LoginManager(app) @LOGIN_MANAGER.user_loader def load_user(user_id): """ Required by Flask-Login for loading a user by PK. """ return User.query.get(int(user_id)) # Return a "Nobody" instance as the anonymous user here for Flask-Login LOGIN_MANAGER.anonymous_user = lambda: Nobody() # ------------------------------------------------------------------------------------------------- class Event(Model): """ A record for a specific cubing event -- the name of the puzzle, the total number of solves to be completed by a competitor, and an optional description of the event. """ __tablename__ = 'events' id = Column(Integer, primary_key=True) name = Column(String(64), index=True, unique=True) totalSolves = Column(Integer) description = Column(String(2048)) eventFormat = Column(Enum("Ao5", "Mo3", "Bo3", "Bo1", name="eventFormat"), default="Ao5") CompEvents = relationship("CompetitionEvent", backref="Event")
login_manager = LoginManager() login_manager.init_app(webapp) # Handle authentication @login_manager.user_loader def load_user(user_id): print "user:", user_id try: return User.get(user_id) except: return None login_manager.anonymous_user = User.get_default_user @api.before_request @login_required def api_login_required(): pass @frontend.before_request def frontend_login_required(): if not current_user.is_authenticated(): if (request.endpoint and request.endpoint != 'frontend.static'): return login_manager.unauthorized()
open_id = OpenID(app) class AdminUser(UserMixin): id = u'1' name = 'admin' active = True def is_active(self): return self.active admin_user = AdminUser() login_manager = LoginManager() login_manager.setup_app(app) login_manager.anonymous_user = AnonymousUser 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): if int(id) == 1: return admin_user else: return None @app.route("/login", methods=["GET", "POST"]) @open_id.loginhandler def login(): if request.method == "POST":
#Import of email must come after cfg/db load from SpaceDock.email import Email email = Email(cfg) login_manager = LoginManager() login_manager.init_app(app) #Import must come after DB loads from SpaceDock.api import API api = API(app, documentation, cfg, db, email, profiler, search) @app.before_first_request def prepare(): db.init_db() from SpaceDock.objects import User @login_manager.user_loader def load_user(username): return User.query.filter(User.username == username).first() login_manager.anonymous_user = lambda: None if __name__ == '__main__': if cfg.get_environment() == 'dev': app.debug = True app.config['JSON_ADD_STATUS'] = False app.config['JSON_JSONP_OPTIONAL'] = False app.secret_key = cfg['secret-key'] app.run(host = cfg['debug-host'], port = cfg.geti('debug-port'))
app = Flask(__name__) app.config.from_object('config') db = SQLAlchemy(app) lm = LoginManager() lm.init_app(app) lm.login_message = None mail = Mail(app) Bootstrap(app) lm.login_view = 'login' migrate = Migrate(app, db) if not app.debug: import logging from logging.handlers import RotatingFileHandler file_handler = RotatingFileHandler(app.config['LOGFILE'], maxBytes=(1024*1024)) file_handler.setLevel(logging.WARNING) app.logger.addHandler(file_handler) bot = praw.Reddit( client_id=app.config['BOT_REDDIT_CLIENT_ID'], client_secret=app.config['BOT_REDDIT_CLIENT_SECRET'], username=app.config['BOT_REDDIT_USERNAME'], password=app.config['BOT_REDDIT_PASSWORD'], user_agent=app.config['BOT_REDDIT_USER_AGENT'], ) from cbbpoll import views, models, admin lm.anonymous_user = models.AnonymousUser app.jinja_env.globals['timestamp'] = views.timestamp
from flask_login import LoginManager from joneame import app from joneame.database import db from joneame.mixins import MyAnonymousUserMixin from joneame.models import User # initialise the login manager login_manager = LoginManager(app) login_manager.anonymous_user = MyAnonymousUserMixin @login_manager.user_loader def load_user(id): query = User.query.options(db.joinedload(User.avatar)) return query.get(int(id))
def get_id(self): return None app = Flask(__name__, static_folder='static', static_url_path='/static') import sys if "debug" in sys.argv: print("Flask running in debug mode!") app.debug = True app.config.from_object('config.BaseConfig') app.jinja_env.add_extension('jinja2.ext.do') db = SQLAlchemy(app) lm = LoginManager() lm.anonymous_user = AnonUser lm.init_app(app) lm.login_view = 'login' lm.login_message = 'Please log in to access this page.' mail = Mail(app) babel = Babel(app) csrf = CsrfProtect(app) if "debug" in sys.argv: print("Installing debug toolbar!") toolbar = DebugToolbarExtension(app) if not app.debug: import logging from logging.handlers import RotatingFileHandler file_handler = RotatingFileHandler('tmp/wlnupdates.log', 'a', 1 * 1024 * 1024, 10)
def get_id(self): return None app = Flask(__name__, static_folder='static', static_url_path='/static') import sys if "debug" in sys.argv: print("Flask running in debug mode!") app.debug = True app.config.from_object('config.BaseConfig') app.jinja_env.add_extension('jinja2.ext.do') db = SQLAlchemy(app) lm = LoginManager() lm.anonymous_user = AnonUser lm.init_app(app) lm.login_view = 'login' lm.login_message = 'Please log in to access this page.' mail = Mail(app) babel = Babel(app) csrf = CSRFProtect(app) if "debug" in sys.argv: print("Installing debug toolbar!") toolbar = DebugToolbarExtension(app) if not app.debug: import logging from logging.handlers import RotatingFileHandler file_handler = RotatingFileHandler('tmp/tob2.log', 'a', 1 * 1024 * 1024, 10)
self.pref.prod_price_region_others = 10000002 self.pref.prod_price_type_minerals = 'buy' self.pref.prod_price_type_pi = 'buy' self.pref.prod_price_type_moongoo = 'buy' self.pref.prod_price_type_others = 'buy' self.pref.prod_te_implant = 1.00 self.pref.reaction_facility = 5 self.pref.reaction_me_rig = 0 self.pref.reaction_te_rig = 0 self.pref.reaction_security = 'l' self.pref.reaction_system = 'Rakapas' self.pref.reaction_manuf_facility = 0 self.pref.reaction_manuf_me_rig = 0 self.pref.reaction_manuf_te_rig = 0 self.pref.reaction_manuf_security = 'h' self.pref.reaction_manuf_system = 'Jita' self.pref.reaction_manuf_te_implant = 1.00 self.pref.reaction_price_regions = 10000002 self.pref.reaction_price_type = 'buy' login_manager = LoginManager() login_manager.anonymous_user = LazyAnonymous login_manager.login_view = 'sso.login' @login_manager.user_loader def load_user(character_id): return User.query.get(character_id)
# We log a warning if the version of flask-login is less than FLASK_LOGIN_LIMIT FLASK_LOGIN_LIMIT = '0.3.0' from .pwdmanager import userdb, LmfdbUser, LmfdbAnonymousUser base_url = "http://beta.lmfdb.org" @login_manager.user_loader def load_user(userid): return LmfdbUser(userid) login_manager.login_view = "users.info" # this anonymous user has the is_admin() method login_manager.anonymous_user = LmfdbAnonymousUser def get_username(uid): """returns the name of user @uid""" return LmfdbUser(uid).name # globally define user properties and username @app.context_processor def ctx_proc_userdata(): userdata = {} userdata['user_can_write'] = userdb.can_read_write_userdb() if not userdata['user_can_write']:
from .views.admin import bp as admin from .views.mod import bp as mod from .views.errors import bp as errors from .views.messages import bp as messages from . import misc, forms, caching from .socketio import socketio from .misc import SiteAnon, engine # /!\ FOR DEBUGGING ONLY /!\ # from werkzeug.contrib.profiler import ProfilerMiddleware webpack = Webpack() babel = Babel() login_manager = LoginManager() login_manager.anonymous_user = SiteAnon login_manager.login_view = 'login' def create_app(): app = Flask(__name__) app.jinja_env.cache = {} app.config.update(config.get_flask_dict()) app.config['WEBPACK_MANIFEST_PATH'] = 'manifest.json' babel.init_app(app) jwt.init_app(app) webpack.init_app(app) socketio.init_app(app, message_queue=config.app.redis_url, cors_allowed_origins="*", async_mode="gevent") caching.cache.init_app(app) login_manager.init_app(app)
app = Flask(__name__) app.config.from_object('config') db = SQLAlchemy(app) lm = LoginManager() lm.init_app(app) lm.login_message = None mail = Mail(app) Bootstrap(app) lm.login_view = 'login' migrate = Migrate(app, db) if not app.debug: import logging from logging.handlers import RotatingFileHandler file_handler = RotatingFileHandler(app.config['LOGFILE'], maxBytes=(1024 * 1024)) file_handler.setLevel(logging.WARNING) app.logger.addHandler(file_handler) bot = praw.Reddit( client_id=app.config['BOT_REDDIT_CLIENT_ID'], client_secret=app.config['BOT_REDDIT_CLIENT_SECRET'], username=app.config['BOT_REDDIT_USERNAME'], password=app.config['BOT_REDDIT_PASSWORD'], user_agent=app.config['BOT_REDDIT_USER_AGENT'], ) from cbbpoll import views, models, admin lm.anonymous_user = models.AnonymousUser app.jinja_env.globals['timestamp'] = views.timestamp
bootstrap = Bootstrap() db = SQLAlchemy() login_manager = LoginManager() mail = Mail() dropzone = Dropzone() moment = Moment() whooshee = Whooshee() avatars = Avatars() csrf = CSRFProtect() @login_manager.user_loader def load_user(user_id): from albumy.models import User user = User.query.get(int(user_id)) return user login_manager.login_view = 'auth.login' login_manager.login_message_category = 'warning' login_manager.refresh_view = 'auth.re_authenticate' login_manager.needs_refresh_message_category = 'warning' class Guest(AnonymousUserMixin): def can(self, permission_name): return False @property def is_admin(self): return False login_manager.anonymous_user = Guest
from yams_api.utils.logger import log from yams.core.dev.users.methods import User, YAMSAnonymousUser from json import loads, dumps app = Flask(__name__) app.config.from_object("config.APP") app.jinja_env.trim_blocks = True app.jinja_env.lstrip_blocks = True # this should only be used for db operations related to the web interface. # if you are associating models with this, you more than likely want the API DB. app_db = SQLAlchemy(app) db = SQLAlchemy(app) login_manager = LoginManager() login_manager.init_app(app) login_manager.anonymous_user = YAMSAnonymousUser API_HOST = "%s://%s:%s" % (PREFERRED_URL_SCHEME, API.LISTEN_HOST, API.LISTEN_PORT) @login_manager.user_loader def load_user(): # we should be serving static assets from the webserver, but put this in anyway # because hammering the DB or k/v store for N-assets is aggressive if request.endpoint != 'login' and '/static/' not in request.path: # use api_key instead and keep user outside of token? token = request.headers.get('Authorization') if token is None: token = request.args.get('token') if token is not None:
def init_login(app): login_manager = LoginManager() login_manager.login_view = 'login.login' login_manager.anonymous_user = users.MyAnonymousUser @login_manager.user_loader def load_user(_id): return users.get(_id=_id) login_manager.init_app(app) login_blueprint = Blueprint("login", __name__) oauth = OAuth() twitter = oauth.remote_app('twitter', base_url='https://api.twitter.com/1.1/', request_token_url='https://api.twitter.com/oauth/request_token', access_token_url='https://api.twitter.com/oauth/access_token', authorize_url='https://api.twitter.com/oauth/authenticate', app_key='TWITTER' ) oauth.init_app(app) @twitter.tokengetter def get_access_token(token=None): if current_user.is_authenticated(): token = current_user['token'] return token['oauth_token'], token['oauth_token_secret'] else: return None @login_blueprint.route('/oauth-authorized') @twitter.authorized_handler def oauth_authorized(resp): next_url = request.args.get('next') if resp is None: flash(u'You denied the request to sign in.') return redirect(next_url) token = ( resp['oauth_token'], resp['oauth_token_secret'] ) username = resp['screen_name'] email = username + "@papertalk.org" user = users.get(username=username) if not user: user = users.create(username, email, token) login_user(user) return redirect(next_url) @login_blueprint.route('/login') def login(): if current_user.is_authenticated(): return request.referrer callback_url = url_for('.oauth_authorized', next=request.args.get('next') or request.referrer) #callback_url = callback_url.replace("http://", "https://") #print callback_url return twitter.authorize(callback=callback_url or request.referrer or None) app.register_blueprint(login_blueprint)
login_manager = LoginManager() # We log a warning if the version of flask-login is less than FLASK_LOGIN_LIMIT FLASK_LOGIN_LIMIT = '0.3.0' from pwdmanager import userdb, LmfdbUser, LmfdbAnonymousUser base_url = "http://beta.lmfdb.org" @login_manager.user_loader def load_user(userid): return LmfdbUser(userid) login_manager.login_view = "users.info" # this anonymous user has the is_admin() method login_manager.anonymous_user = LmfdbAnonymousUser def get_username(uid): """returns the name of user @uid""" return LmfdbUser(uid).name # globally define user properties and username @app.context_processor def ctx_proc_userdata(): userdata = {} userdata['user_can_write'] = userdb.can_read_write_userdb() if not userdata['user_can_write']: userdata['userid'] = 'anon'