import logging from logging.handlers import SMTPHandler, RotatingFileHandler import os from flask import Flask, request, current_app from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate from flask_login import LoginManager from flask_mail import Mail from flask_bootstrap import Bootstrap from flask_moment import Moment from flask_babel import Babel, lazy_gettext as _l from config import Config db = SQLAlchemy() migrate = Migrate() login = LoginManager() login.login_view = 'auth.login' login.login_message = _l('Please log in to accesss this page.') mail = Mail() bootstrap = Bootstrap() moment = Moment() babel = Babel() def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(config_class) db.init_app(app) migrate.init_app(app, db) login.init_app(app)
from flask import Flask, jsonify, g import models from flask_login import LoginManager from flask_cors import CORS from resources.animals import animal from resources.shelters import shelter from resources.admin import admin DEBUG = True #I don't want any errors but when I get them I want them to be better PORT = 8000 #localhost 8000 # This initializes Flask app = Flask(__name__) # __name__ == "__main__" app.secret_key = 'asldn;alisdngl;asdnl;kadsnalksdnglkasdn' login_manager = LoginManager() #<-- apparently you need these parentheses login_manager.init_app(app) @login_manager.user_loader def load_user(adminid): try: return models.Admin.get(models.Admin.id == adminid) except models.DoesNotExist: return None @login_manager.unauthorized_handler def unauthorized(): return jsonify(data={'ERROR'}, status={
if user is not None: click.echo('更新用户') user.username = username user.set_password(password) else: click.echo('创建用户') user = User(username=username, name="Admin") user.set_password(password) db.session.add(user) db.session.commit() click.echo('创建管理员账号完成') # Flask-login 初始化操作 login_manager = LoginManager(app) # 实例化扩展类 @login_manager.user_loader def load_user(user_id): # 创建用户加载回调函数,接受用户ID作为参数 from watchlist.models import User user = User.query.get(int(user_id)) return user # LoginManager.login_view = 'login' # # 设置 # login_manager
def create_app(): app = Flask(__name__) app.config.from_pyfile('config.py') db.init_app(app) # Инициализируем базу данных # Атрибуты логин менеджмента login_manager = LoginManager() login_manager.init_app(app) # Инициализируем логин менежера login_manager.login_view = 'login' # Указываем какая функция отвечает за авторизацию # Проверяем кеш пользователя на момент наличия авторизации, дабы всякие не шлялись @login_manager.user_loader def load_user(user_id): return User.query.get(user_id) @app.route('/') def index(): # не пускаем на главную страницу, если нет авторизации if not current_user.is_authenticated: return redirect(url_for('login')) page_title = 'PythonApp' weather = weather_by_city(app.config['WEATHER_DEFAULT_CITY']) news_list = News.query.order_by(News.date.desc()).all() # БД_новости.запрос.при_этом_отфильтровать_по(БД_новости.дата_пудликации.в_обратном_порядке()).все_данные() return render_template('index.html', weather=weather, page_title=page_title, news_list=news_list) @app.route('/login') def login(): # Если пользователь уже авторизован, то не нужно его деражать на странице авторизации, # а сразу перекидываем его на главную страницу. Иначе же, запрашиваем форму авторизации print(current_user) if current_user.is_authenticated: return redirect(url_for('index')) title = 'Авторизация' login_form = LoginForm() return render_template('login.html', page_title=title, form=login_form) @app.route('/process-login', methods=['POST']) def process_login(): form = LoginForm() # Запрашиваем пользователя из базы данных if form.validate_on_submit(): # Пытаемся получить такого пользователя по имени из базы данных user = User.query.filter(User.username == form.username.data).first() if user and user.check_password(form.password.data): login_user(user) # Авторизуем пользователя на странице flash('Вы успешно вошли на сайт') # Говорим ему, что он красавчег return redirect(url_for('index')) # Редирект на главную страницу программы # Если авторизация не корректная flash('Неправильное имя или пароль') return redirect(url_for('login')) @app.route('/logout') def logout(): logout_user() flash('Вы успешно разлогинелись') return redirect(url_for('index')) @app.route('/admin') @login_required # Дикортаор, для проверки ролей def admin_index(): if current_user.is_admin: return 'Hello, ADMIN !!!' flash('Административный доступ запрещен!') return redirect(url_for('login')) return app
import os from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_login import LoginManager from flask_openid import OpenID from config import basedir app = Flask(__name__) app.config.from_object("config") app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) lm = LoginManager(app) lm.login_view = "login" oid = OpenID(app, os.path.join(basedir, "tmp")) from app import views, models
from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_login import LoginManager, login_user, logout_user, current_user, login_required from datetime import datetime app = Flask(__name__) app.config['SECRET_KEY'] = 'webdev' app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) login_manager = LoginManager(app) login_manager.init_app(app) login_manager.login_view = 'login' login_manager.login_message_category = 'info' from ecom import routes
# third-party imports from flask import Flask, render_template from flask_sqlalchemy import SQLAlchemy from flask_login import LoginManager from flask_migrate import Migrate from flask_bootstrap import Bootstrap # local imports from config import app_config # db variable initialization db = SQLAlchemy() # user login management login_manager = LoginManager() # create app object def create_app(config_name): if os.getenv('FLASK_CONFIG') == "production": app = Flask(__name__) app.config.update( SECRET_KEY=os.getenv('SECRET_KEY'), SQLALCHEMY_DATABASE_URI=os.getenv('SQLALCHEMY_DATABASE_URI')) else: app = Flask(__name__, instance_relative_config=True) app.config.from_object(app_config[config_name]) app.config.from_pyfile('config.py') db.init_app(app)
import os from flask import Flask from config import Config from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate from flask_login import LoginManager import logging from logging.handlers import SMTPHandler, RotatingFileHandler myApp = Flask(__name__) myApp.config.from_object(Config) db = SQLAlchemy(myApp) migrate = Migrate(myApp, db) login = LoginManager(myApp) login.login_view = 'login' if not myApp.debug: if myApp.config['MAIL_SERVER']: auth = None if myApp.config['MAIL_USERNAME'] or myApp.config['MAIL_PASSWORD']: auth = (myApp.config['MAIL_USERNAME'], myApp.config['MAIL_PASSWORD']) secure = None if myApp.config['MAIL_USE_TLS']: secure = () mail_handler = SMTPHandler( mailhost=(myApp.config['MAIL_SERVER'], myApp.config['MAIL_PORT']), fromaddr='no-reply@' + myApp.config['MAIL_SERVER'], toaddrs=myApp.config['ADMINS'], subject='Microblog Failure', credentials=auth,
APP.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER APP.config['SHARED_FOLDER'] = SHARED_FOLDER APP.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0 APP.config.update( dict( SECRET_KEY='development key', USERNAME='******', PASSWORD='******', SESSION_COOKIE_PATH='/', SQLALCHEMY_TRACK_MODIFICATIONS=False, )) APP.config.from_envvar('FLASKR_SETTINGS', silent=True) DB = SQLAlchemy(APP) LOGIN = LoginManager() # ------------------------------- controller imports ----------------------------------------- # # Each of them is abstracted as blueprints specific to their tasks from app.controllers.main import MAIN from app.controllers.auth import AUTH from app.controllers.share import SHARED # Registering imported Blueprints APP.register_blueprint(MAIN) APP.register_blueprint(AUTH) APP.register_blueprint(SHARED) # ------------------------------- Initialising DB -------------------------------------------
try: random = random.SystemRandom() except NotImplementedError: LOG.critical("Insecure random! Please make random.SystemRandom available!") # noinspection PyUnusedLocal def generate_session_key(length): return ''.join([ random.choice( 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789') for i in range(length) ]) auth = LoginManager() auth.login_view = "home.index.login" auth.session_protection = "strong" auth_hasher = Bcrypt() @auth.user_loader def load_user(session_token): return User.query.filter_by(token=session_token).first() def do_login(username, password): user = User.query.filter_by(username=username).first() if user is None:
import os import logging from logging.handlers import SMTPHandler, RotatingFileHandler from flask import Flask from config import Config from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate from flask_login import LoginManager from flask_bootstrap import Bootstrap from flask_mail import Mail from flask_moment import Moment from elasticsearch import Elasticsearch db = SQLAlchemy() migrate = Migrate() loginm = LoginManager() loginm.login_view = 'auth.login' loginm.login_message = ('Please log in to access this page.') bootstrap = Bootstrap() mail = Mail() moment = Moment() def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(config_class) db.init_app(app) migrate.init_app(app, db) loginm.init_app(app) bootstrap.init_app(app)
from flask import Flask from config import Config from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate from flask_login import LoginManager gem = Flask(__name__) gem.config.from_object(Config) db = SQLAlchemy(gem) migrate = Migrate(gem, db) login = LoginManager(gem) login.login_view = 'login' from gem import routes, models
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'templates', static_folder=u'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() # Plaso version that we support if app.config[u'UPLOAD_ENABLED']: try: from plaso import __version__ as plaso_version except ImportError: sys.stderr.write(u'Upload is enabled, but Plaso is not installed.') sys.exit() app.config[u'PLASO_VERSION'] = plaso_version # 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(auth_views) app.register_blueprint(home_views) app.register_blueprint(sketch_views) # Setup URL routes for the API. api_v1 = Api(app, prefix=u'/api/v1') for route in V1_API_ROUTES: api_v1.add_resource(*route) # Setup URL routes for the experimental API. api_experimental = Api(app, prefix=u'/api/experimental') for route in EXP_API_ROUTES: api_experimental.add_resource(*route) # 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
from flask import Flask from flask_sqlalchemy import Model, SQLAlchemy from flask_bcrypt import Bcrypt from flask_login import LoginManager app = Flask(__name__) app.config['SECRET_KEY'] = '2b3b0653a9d3c42948bd5edce8fd84cb' app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db' #creating a local SQlite Database app.config[ 'SQLALCHEMY_TRACK_MODIFICATIONS'] = False #Removes tracking of changes to the database db = SQLAlchemy(app) #Assigning our database to SQLAlchemey bcrypt = Bcrypt(app) ##Flask library used to hash passwords login_manager = LoginManager( app) #Flask library to manage login on our web application login_manager.login_view = 'login_page' login_manager.login_message_category = 'info' from cardealer import routes
file_path = os.path.join(os.path.dirname(__file__), 'uploads') # Initialize Flask and set some config values app = Flask(__name__) app.config['DEBUG'] = True app.config['SECRET_KEY'] = 'super-secret' app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'mysql://*****:*****@127.0.0.1:3306/zsky' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True app.config['SQLALCHEMY_POOL_SIZE'] = 5000 db = SQLAlchemy(app) manager = Manager(app) migrate = Migrate(app, db) babel = Babel(app) app.config['BABEL_DEFAULT_LOCALE'] = 'zh_CN' loginmanager = LoginManager() loginmanager.init_app(app) loginmanager.session_protection = 'strong' loginmanager.login_view = 'login' loginmanager.login_message = "请先登录!" cache = Cache(app, config={ 'CACHE_TYPE': 'redis', 'CACHE_REDIS_HOST': '127.0.0.1', 'CACHE_REDIS_PORT': 6379, 'CACHE_REDIS_DB': '', 'CACHE_REDIS_PASSWORD': '' }) cache.init_app(app) DB_HOST = '127.0.0.1'
def __init__(self, repo, db_uri=None, debug=None, config=None, **kwargs): Flask.__init__(self, __name__, template_folder='templates', static_folder='static') # Add unique identifier for this application isinstance self.uuid = str(uuid.uuid4()) if 'KNOWLEDGE_REPO_MASTER_UUID' not in os.environ: os.environ['KNOWLEDGE_REPO_MASTER_UUID'] = self.uuid # Preload default configuration self.config.from_object('knowledge_repo.app.config_defaults') # Load configuration from file or provided object if config: if isinstance(config, str): config = imp.load_source('knowledge_server_config', os.path.abspath(config)) self.config.from_object(config) # Add configuration passed in as keyword arguments self.config.update(kwargs) # Prepare repository, and add it to the app if hasattr(config, 'prepare_repo'): repo = config.prepare_repo(repo) self.repository = repo assert isinstance(self.repository, knowledge_repo.KnowledgeRepository), "Invalid repository object provided." # Set debug mode from kwargs or else maintain current setting if debug is not None: self.config['DEBUG'] = debug # Set the secret key for this instance (creating one if one does not exist already) self.config['SECRET_KEY'] = self.config['SECRET_KEY'] or str(uuid.uuid4()) # Configure database if db_uri: self.config['SQLALCHEMY_DATABASE_URI'] = db_uri logger.debug(u"Using database: {}".format(self.config['SQLALCHEMY_DATABASE_URI'])) # Register database schema with flask app sqlalchemy_db.init_app(self) # Set up database migration information # Registers Migrate plugin in self.extensions['migrate'] Migrate(self, self.db) # Try to create the database if it does not already exist # Existence is determined by whether there is an existing alembic migration revision db_auto_create = self.config.get('DB_AUTO_CREATE', True) db_auto_upgrade = self.config.get('DB_AUTO_UPGRADE', True) if db_auto_create and self.db_revision is None: self.db_init() elif db_auto_upgrade: self.db_upgrade() # Initialise login manager to keep track of user sessions LoginManager().init_app(self) self.login_manager.login_view = 'auth.login' self.login_manager.anonymous_user = AnonymousKnowledgeUser @self.login_manager.user_loader def load_user(user_id): return User(identifier=user_id) # Attempt login via http headers if header is specified if self.config.get('AUTH_USER_IDENTIFIER_REQUEST_HEADER'): @self.login_manager.request_loader def load_user_from_request(request): identifier = request.headers.get(current_app.config['AUTH_USER_IDENTIFIER_REQUEST_HEADER']) if identifier: if current_app.config['AUTH_USER_IDENTIFIER_REQUEST_HEADER_MAPPING']: identifier = current_app.config['AUTH_USER_IDENTIFIER_REQUEST_HEADER_MAPPING'](identifier) user = User(identifier=identifier) user.can_logout = False user = prepare_user(user, session_start=False) return user # Intialise access policies self.principal = Principal(self) # Add AnonymousIdentity fallback so that on_identity_loaded is called for # anonymous users too. self.principal.identity_loaders.append(lambda: AnonymousIdentity()) # Synchronise user permissions with data model @user_loaded_from_request.connect def on_user_loaded_from_request(sender, user): self.principal.set_identity(Identity(user.id)) @identity_loaded.connect_via(self) def on_identity_loaded(sender, identity): populate_identity_roles(identity, user=current_user) @self.errorhandler(PermissionDenied) def handle_insufficient_permissions(error): return render_template('permission_denied.html'), 403 # Add mail object if configuration is supplied if self.config.get('MAIL_SERVER'): self.config['mail'] = Mail(self) # Register routes to be served self.register_blueprint(routes.posts.blueprint) self.register_blueprint(routes.health.blueprint) self.register_blueprint(routes.index.blueprint) self.register_blueprint(routes.tags.blueprint) self.register_blueprint(routes.vote.blueprint) self.register_blueprint(routes.comment.blueprint) self.register_blueprint(routes.stats.blueprint) self.register_blueprint(routes.editor.blueprint) self.register_blueprint(routes.groups.blueprint) self.register_blueprint(routes.auth.blueprint) KnowledgeAuthProvider.register_auth_provider_blueprints(self) if self.config['DEBUG']: self.register_blueprint(routes.debug.blueprint) # Register error handler @self.errorhandler(500) def show_traceback(self): """ If LOCAL MODE: show the stack trace on a server error otherwise show a nice error template to the users """ if current_app.config.get("DEBUG"): return render_template('traceback.html', info=traceback.format_exc()), 500 else: return render_template('error.html') @self.before_first_request def ensure_excluded_tags_exist(): # For every tag in the excluded tags, create the tag object if it doesn't exist excluded_tags = current_app.config['EXCLUDED_TAGS'] for tag in excluded_tags: Tag(name=tag) db_session.commit() # Set up indexing timers set_up_indexing_timers(self) @self.before_request def open_repository_session(): if not request.path.startswith('/static'): current_repo.session_begin() @self.after_request def close_repository_session(response): if not request.path.startswith('/static'): current_repo.session_end() return response @self.context_processor def webediting_enabled(): # TODO: Link this more to KnowledgeRepository capability and # configuration rather than a specific name. return {"webeditor_enabled": 'webposts' in current_repo.uris} @self.context_processor def inject_version(): version = knowledge_repo.__version__ version_revision = None if '_' in knowledge_repo.__version__: version, version_revision = version.split('_') return dict(version=version, version_revision=version_revision, last_index=time_since_index(human_readable=True), last_index_check=time_since_index_check(human_readable=True)) @self.template_global() def modify_query(**new_values): args = request.args.copy() for key, value in new_values.items(): args[key] = value return u'{}?{}'.format(request.path, url_encode(args)) @self.template_global() def pagination_pages(current_page, page_count, max_pages=5, extremes=True): page_min = int(max(1, current_page - math.floor(1.0 * max_pages // 2))) page_max = int(min(page_count, current_page + math.floor(1.0 * max_pages / 2))) to_acquire = max_pages - (page_max - page_min + 1) while to_acquire > 0 and page_min > 1: page_min -= 1 to_acquire -= 1 while to_acquire > 0 and page_max < page_count: page_max += 1 to_acquire -= 1 pages = list(range(page_min, page_max + 1)) if extremes: if 1 not in pages: pages[0] = 1 if page_count not in pages: pages[-1] = page_count return pages @self.template_filter('format_date') def format_date(date): """ This will be a Jinja filter that string formats a datetime object. If we can't correctly format, we just return the object. :type date: Datetime :return: A string of the format of YYYY-MM-DD :rtype: String """ try: return datetime.strftime(date, '%Y-%m-%d') except: return date
import os import pytz from connect import * app = Flask(__name__) try: app.config['MONGOALCHEMY_DATABASE'] = os.environ['DB_NAME'] app.config['MONGOALCHEMY_CONNECTION_STRING'] = os.environ['DB_URI'] except EnvironmentError as e: print( "Make sure you have DB_NAME and DB_URI Environment variables defined.") raise e app.secret_key = "blackbird" # shh it's a secret # Bcrypt bcrypt.init_app(app) # Initialize BCrypt -- imported from mongo.py # Database db.init_app(app) # Initialize Database Connection -- imported from mongo.py # Login Manager lm = LoginManager() lm.init_app(app) # Initialize Login Manager lm.login_view = "index" lm.login_message = "Please enter your Employee ID and Password below." tz = pytz.timezone('America/Los_Angeles') time_string = '%m/%d/%Y %I:%M %p'
# @Time : 2020/2/4 18:11 # @Author : tongyue from flask import Flask from flask_login import LoginManager login_manager = LoginManager( ) #创建login_manager ,保存cookie,需要在场景中导入flask_login的 login_user # from app.web.book import web 改成如下 from app.web import web from app.models.book import db from app.models.user import User @login_manager.user_loader def load_user(user_id): user = db.session.query(User).get(user_id) return user def create_app(): app = Flask(__name__) register_blueprint(app) login_manager.init_app(app) #初始化login_manager login_manager.login_view = 'web.login' #直接访问gifts会报错并且重定向到web.login,登录后在定位到gifts login_manager.login_message = "请先登录或者注册" #直接访问gifts没权限的自动flash闪现消息 ''' 初始化配置文件 统一flask的app对象管理 其他文件不好读取app,可以from flask import current_app
SECRET_KEY = os.urandom(32) app.config['SECRET_KEY'] = SECRET_KEY #Configure database app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'postgres://*****:*****@ec2-23-21-248-1.compute-1.amazonaws.com:5432/ddn24ofdllas71' app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False db = SQLAlchemy(app) # Initialize Flask-SockIO socketio = SocketIO(app) ROOMS = ["longue", "news", "games", "coding"] # Configure flask login login = LoginManager(app) login.init_app(app) @login.user_loader def load_user(id): return User.query.get(int(id)) @app.route("/", methods=["GET", "POST"]) def index(): reg_form = RegistrationForm() # Update database if validation success if reg_form.validate_on_submit(): username = reg_form.username.data
# 扩展类实例化 from flask_sqlalchemy import SQLAlchemy from flask_login import LoginManager from flask_bootstrap import Bootstrap from flask_wtf.csrf import CSRFProtect db = SQLAlchemy() # 数据库实例化 login_manager = LoginManager() #扩展登录功能 bootstrap = Bootstrap() #扩展Bootstrap csrf = CSRFProtect() #CSRF保护 # 用户加载函数 @login_manager.user_loader def load_user(user_id): from edatribe.models import Admin user = Admin.query.get(int(user_id)) return user # 页面保护 -> 登录视图 login_manager.login_view = 'auth.login'
from nl.oppleo.webapp.flaskRoutes import flaskRoutes from nl.oppleo.utils.WebSocketUtil import WebSocketUtil from nl.oppleo.utils.BackupUtil import BackupUtil # Create an emit queue, for other Threads to communicate to th ews emit background task wsEmitQueue = Queue() oppleoConfig.wsEmitQueue = wsEmitQueue oppleoSystemConfig.wsEmitQueue = wsEmitQueue # The Oppleo root flaskRoutes app.register_blueprint(flaskRoutes) # no url_prefix # flask-login oppleoConfig.login_manager = LoginManager() oppleoConfig.login_manager.init_app(app) threadLock = threading.Lock() wsqrbBackgroundTask = WebSocketQueueReaderBackgroundTask() wsClientCnt = 0 # Resource is only served for logged in user if allowed in preferences def config_dashboard_access_restriction(function): @wraps(function) def decorated(*args, **kwargs): # Allow dashboard and Usage table access if unrestructed in config # request.remote_addr - returns remote address, or IP of reverse proxy # request.headers.get('X-Forwarded-For') - returns router address (router is behind the reverse proxy)
""" return None def get_token(self): """ Return anonymous token for anonymous user. """ anonymous_token = session.get('anonymous_token') if anonymous_token is None: anonymous_token = secrets.token_hex(256) session['anonymous_token'] = anonymous_token return anonymous_token # Initiate LoginManager object login_manager = LoginManager(application) login_manager.anonymous_user = AnonymousUser login_manager.session_protection = 'strong' # Import and register blueprint modules # (prevent circular imports) for module_name, url_prefix in BLUEPRINTS_NAME_WITH_URL_PREFIX: module = importlib.import_module('blueprints.%s' % module_name) application.register_blueprint(module.blueprint, url_prefix=url_prefix) # Initiate Paranoid object paranoid = Paranoid(application) paranoid.redirect_view = BLUEPRINTS_ROOT_HANDLER # Import UserStore from models from models import UserStore