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
