def register_extensions(app):
# Flask-SQLAlchemy
db.init_app(app)
db.app = app
# Flask-Redis
# rd.init_app(app)
# Flask-Migrate
# migrate.init_app(app, db)
# Flask-Mail
mail.init_app(app)
# Flask-Cache
# cache.init_app(app)
# Flask-Login
from models import AnonymousUser
login_manager.session_protection = 'basic'
login_manager.login_view = 'blog.articles'
login_manager.login_message = 'please login first~'
login_manager.anonymous_user = AnonymousUser
login_manager.init_app(app)
def create_app():
app = Flask(__name__, static_folder='static', template_folder='templates')
app.config.from_object("config.Config")
from main import main
app.register_blueprint(main)
from api.misc import misc_api
app.register_blueprint(misc_api)
from api.corrections import corrections_api
app.register_blueprint(corrections_api)
from api.users import users_api
app.register_blueprint(users_api)
from api.archive import archive_api
app.register_blueprint(archive_api)
from auth import auth_blueprint
app.register_blueprint(auth_blueprint)
from extensions import mail
mail.init_app(app)
return app
def configure_extensions(app):
db.app = app
db.init_app(app)
mail.init_app(app)
cache.init_app(app)
celery.conf.update(app.config)
rd.init_app(app)
def init_extensions(app):
db.init_app(app)
db.app = app
db.metadata.naming_convention = {
"ix": 'ix_%(column_0_label)s',
"uq": "uq_%(table_name)s_%(column_0_name)s",
"ck": "ck_%(table_name)s_%(column_0_name)s",
"fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
"pk": "pk_%(table_name)s"
}
# set constraint naming convention to sensible default, per
# http://docs.sqlalchemy.org/en/rel_0_9/core/constraints.html#configuring-constraint-naming-conventions
assets.init_app(app)
assets.app = app
babel.init_app(app)
cache.init_app(app)
csrf.init_app(app)
mail.init_app(app)
login_manager.init_app(app)
rq.init_app(app)
app.rq = rq
store.init_app(app)
rest.init_app(app, flask_sqlalchemy_db=db,
preprocessors=restless_preprocessors)
rest.app = app
limiter.init_app(app)
for handler in app.logger.handlers:
limiter.logger.addHandler(handler)
if app.config.get('DEBUG'):
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
app.debug = True
def register_extensions(app):
db.init_app(app)
bootstrap.init_app(app)
moment.init_app(app)
whooshee.init_app(app)
loginmanager.init_app(app)
mail.init_app(app)
def init_extensions(app):
# Init database
from extensions import db
db.init_app(app)
# Init migration
from extensions import migrate
migrate.init_app(app, db)
# Init bcrypt
from extensions import bcrypt
bcrypt.init_app(app)
# Init Login manager
from extensions import login_mgr
login_mgr.login_view = 'auth.login'
login_mgr.init_app(app)
# Init mail
from extensions import mail
mail.init_app(app)
# Init jwt
from extensions import jwt
jwt.init_app(app)
def create_app(config_file):
app = Flask(__name__)
app.config.from_object(config_file)
app.config.update(
SESSION_COOKIE_SECURE=True,
SESSION_COOKIE_HTTPONLY=True,
SESSION_COOKIE_SAMESITE='Lax',
)
csrf = CSRFProtect(app)
csrf = CSRFProtect()
app.config['SECRET_KEY'] = os.environ.get("CSRF_KEY_SECRET")
app.secret_key = b'\x06\x82\x96n\xfa\xbb(L\x97n\xb8.c\\y\x8a'
login_manager.init_app(app)
csrf.init_app(app)
mail.init_app(app)
app.register_blueprint(router, url='/router')
css = Blueprint(
'css',
__name__,
template_folder='templates',
static_folder='static/css',
static_url_path='/static/css'
)
js = Blueprint(
'js',
__name__,
template_folder='templates',
static_folder='static/js',
static_url_path='/static/js'
)
app.register_blueprint(js)
return app
def register_extensions(app):
db.init_app(app)
migrate = Migrate(app, db)
jwt.init_app(app)
mail.init_app(app)
cache.init_app(app)
limiter.init_app(app)
def configure_extensions(app):
db.app = app
celery.init_app(app)
db.init_app(app)
mail.init_app(app)
cache.init_app(app)
celery.init_app(app)
def register_extensions(app):
db.init_app(app)
mail.init_app(app)
debug_toolbar.init_app(app)
migrate.init_app(app, db)
api.init_app(app)
return None
def init_extensions(app):
db.init_app(app)
db.app = app
db.metadata.naming_convention = {
"ix": 'ix_%(column_0_label)s',
"uq": "uq_%(table_name)s_%(column_0_name)s",
"ck": "ck_%(table_name)s_%(column_0_name)s",
"fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
"pk": "pk_%(table_name)s"
}
# set constraint naming convention to sensible default, per
# http://docs.sqlalchemy.org/en/rel_0_9/core/constraints.html#configuring-constraint-naming-conventions
assets.init_app(app)
assets.app = app
babel.init_app(app)
cache.init_app(app)
csrf.init_app(app)
mail.init_app(app)
login_manager.init_app(app)
store.init_app(app)
rest.init_app(app,
flask_sqlalchemy_db=db,
preprocessors=restless_preprocessors)
rest.app = app
if app.config.get('DEBUG'):
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
def configure_extensions(app):
# I18N
babel.init_app(app)
# Database
db.init_app(app)
# CouchDB
couchdbmanager.setup(app)
couchdbmanager.sync(app)
# Login
login_manager.init_app(app)
login_manager.login_view = "authentification.login"
# Roles
principal.init_app(app)
# Mail
mail.init_app(app)
# Plugins list global
plugin_manager.init_plugin_manager(app.root_path + "/plugins", app)
plugin_manager.activate_plugins()
plugin_manager.setup_plugins()
def register_extensions(app):
bootstrap.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
ckeditor.init_app(app)
mail.init_app(app)
moment.init_app(app)
def extensions(app):
bcrypt.init_app(app)
login.init_app(app)
db.init_app(app)
mail.init_app(app)
return None
def extensions(our_app):
mail.init_app(our_app)
csrf.init_app(our_app)
login_manager.init_app(our_app)
login_manager.login_view = 'user.login'
login_manager.login_message_category = 'info'
return None
def register_extensions(app):
db.init_app(app)
bcrypt.init_app(app)
lm.init_app(app)
lm.login_view = 'auth.login'
toolbar.init_app(app)
mail.init_app(app)
migrate.init_app(app, db)
return None
def create_app(config=None):
new_app = Flask(__name__,
template_folder='../react_app/build',
static_folder='../react_app/build/static')
new_app.config.from_object(config)
with new_app.app_context():
jwt.init_app(new_app)
bcrypt.init_app(new_app)
cors.init_app(new_app)
mysql.init_app(new_app)
mail.init_app(new_app)
from model import temp_blacklist
@jwt.token_in_blacklist_loader
def check_if_token_in_blacklist(decrypted_token):
return decrypted_token['jti'] in temp_blacklist
# Let react handle routing
@new_app.route('/', defaults={'path': ''})
@new_app.route('/<path:path>')
def serve(path):
if path and os.path.exists(safe_join(new_app.template_folder, path)):
return send_from_directory(new_app.template_folder, path)
else:
return send_from_directory(new_app.template_folder, 'index.html')
from resources.authentication import (UserRegistration, UserLogin,
TokenRefresh, UnsetToken, AdminLogin,
AdminRegister)
from resources.user import GetUserInfo, UpdateUserInfo
from resources.products import (TrackProduct, NewComments, GetComments,
GetSpecificProduct)
from resources.admin import Announcement
api.add_resource(UserRegistration, '/register')
api.add_resource(UserLogin, '/login')
api.add_resource(TokenRefresh, '/refresh')
api.add_resource(UnsetToken, '/revoke')
api.add_resource(GetUserInfo, '/user')
api.add_resource(UpdateUserInfo, '/user/<string:option>')
api.add_resource(TrackProduct, '/product')
api.add_resource(GetSpecificProduct,
'/product/<string:retailer>/<string:pid>')
api.add_resource(NewComments, '/comment')
api.add_resource(GetComments,
'/comment/<string:retailer>/<string:prod_id>')
api.add_resource(AdminLogin, '/admin-login')
api.add_resource(AdminRegister, '/admin-register')
api.add_resource(Announcement, '/announcement')
api_bp = Blueprint('api', __name__)
api.init_app(api_bp)
new_app.register_blueprint(api_bp, url_prefix='/api')
return new_app
def extensions(app):
"""
Register 0 or more extensions (mutates the app passed in).
:param app: Flask application instance
:return: None
"""
mail.init_app(app)
return None
def register_extensions(app):
bootstrap.init_app(app)
db.init_app(app)
login_manager.init_app(app)
mail.init_app(app)
dropzone.init_app(app)
moment.init_app(app)
whooshee.init_app(app)
avatars.init_app(app)
csrf.init_app(app)
def register_extensions(app):
cache.init_app(app)
db.init_app(app)
admin.init_app(app)
register_admin_views(admin)
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore, confirm_register_form=ExtendedRegisterForm)
mail.init_app(app)
debug_toolbar.init_app(app)
return None
def register_extensions(app):
cache.init_app(app)
db.init_app(app)
admin.init_app(app)
register_admin_views(admin)
user_datastore = MongoEngineUserDatastore(db, User, Role)
security = Security(app, user_datastore, confirm_register_form=ExtendedRegisterForm)
mail.init_app(app)
debug_toolbar.init_app(app)
return None
def create_app(script_info=None):
app = Flask(__name__)
load_dotenv(".env", verbose=True)
app_settings = os.environ.get("APP_SETTINGS")
if not app_settings:
raise ValueError(
'APP_SETTINGS environment variable is not set. Aborting.')
app.config.from_object(app_settings)
# Migration purposes
from models import user, remaining_employee, company, address # NOQA
jwt.init_app(app)
db.init_app(app)
api.init_app(app)
ma.init_app(app)
migrate.init_app(app, db)
init_celery(app)
mail.init_app(app)
api.add_resource(UserLogin, "/login")
api.add_resource(UserRegister, "/register")
api.add_resource(UserRegister, "/register/<string:confirmation_token>")
api.add_resource(User, "/user")
api.add_resource(UserList, "/users")
api.add_resource(UserInvite, "/invite")
@app.route('/ping')
def pong():
return 'pong'
@api.errorhandler(Unauthorized)
def unauthorized_page(error):
return {"message": "401, change this on prod."}, 401
@api.errorhandler(Forbidden)
def forbidden_page(error):
return {"message": "403, change this on prod."}, 403
@api.errorhandler(NotFound)
def page_not_found(error):
return {"message": "404, change this on prod."}, 404
@api.errorhandler(MethodNotAllowed)
def method_not_allowed(error):
return {"message": "405, change this on prod."}, 405
@api.errorhandler(InternalServerError)
def server_error_page(error):
return {"message": "500, change this on prod."}, 500
return app
def configure_extensions(app):
# setup SQLAlchemy
db.init_app(app)
# db.drop_all(app=app)
db.create_all(app=app)
from dummy_data import create_test_data
# create_test_data(app)
mail.init_app(app)
bcrypt.init_app(app)
def create_app(app_config):
app = Flask(__name__)
app.config.from_object(app_config)
__location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__)))
with open(os.path.join(__location__, 'secrets.json')) as secrets_file:
secrets = json.load(secrets_file)
app.secret_key = secrets.get('app_secret')
app_config.SECRET_KEY = app.secret_key
login_manager.login_view = 'login.show'
admin.add_view(AdminModelView(Challenge, db.session))
admin.add_view(AdminModelView(Game, db.session))
admin.add_view(AdminModelView(MarathonInfo, db.session))
admin.add_view(AdminModelView(Prize, db.session))
admin.add_view(AdminModelView(Interview, db.session))
admin.add_view(AdminModelView(ScheduleEntry, db.session))
with open(os.path.join(__location__, 'secrets.json')) as secrets_file:
secrets = json.load(secrets_file)
app.config.update(
MAIL_SERVER='smtp.gmail.com',
MAIL_PORT=465,
MAIL_USERNAME='******',
MAIL_DEFAULT_SENDER='*****@*****.**',
MAIL_PASSWORD=secrets.get("email_password"),
MAIL_USE_SSL=True,
MAIL_USE_TLS=False
)
login_manager.init_app(app)
admin.init_app(app)
mail.init_app(app)
register_routes(app)
@app.errorhandler(404)
def page_not_found(e):
return render_template('404.tmpl'), 404
@login_manager.user_loader
def load_user(id):
return db.session.query(User).filter_by(id=id).first()
@app.context_processor
def inject_marathon_info():
marathon_info = getattr(g, "marathon_info", None)
if not marathon_info:
marathon_info = g.marathon_info = db.session.query(MarathonInfo).first()
current_game = db.session.query(Game).filter_by(id=marathon_info.current_game_id).first()
return dict(marathon_info=marathon_info, current_game=current_game)
return app
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)
mail.init_app(app)
bootstrap.init_app(app)
moment.init_app(app)
celery.init_app(app)
from app.errors import bp as errors_bp
app.register_blueprint(errors_bp)
from app.auth import bp as auth_bp
app.register_blueprint(auth_bp, url_prefix='/auth')
from app.main import bp as main_bp
app.register_blueprint(main_bp)
from app.scraping import bp as scraping_bp
from app.scraping.scraper import Scraper
from app.scraping import tasks
app.register_blueprint(scraping_bp, url_prefix='/scraping')
app.scrapers = {
"rechem": tasks.rechem_routine_task,
"test_task": tasks.test_task
}
if not app.debug and not app.testing:
if app.config['LOG_TO_STDOUT']:
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.INFO)
app.logger.addHandler(stream_handler)
else:
if not os.path.exists('logs'):
os.mkdir('logs')
file_handler = RotatingFileHandler('logs/DNMS.log',
maxBytes=10240,
backupCount=10)
file_handler.setFormatter(
logging.Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.setLevel(logging.INFO)
app.logger.info('DNMS startup')
return app
def configure_extensions(app):
db.init_app(app)
# login_manager.refresh_view = 'user.reauth'
login_manager.init_app(app)
@login_manager.user_loader
def user_loader(user_email):
return User.query.filter_by(email=user_email).first()
login_manager.login_view = 'user.signin'
login_manager.login_message_category = "info"
mail.init_app(app)
bcrypt.init_app(app)
def configure_extensions(app):
configure_assets(app)
bcrypt.init_app(app)
babel.init_app(app)
cache.init_app(app)
celery = Celery(app)
mail.init_app(app)
mongodb.init_app(app)
sqldb.init_app(app)
if app.debug:
debugtoolbar = DebugToolbarExtension(app)
def register_extensions(app):
from extensions import security, mail, migrate, admin, ckeditor
db.init_app(app)
security.init_app(app, user_datastore, confirm_register_form=ExtendedRegisterForm)
mail.init_app(app)
md = Markdown(app, extensions=['fenced_code', 'tables'])
# migrate.init_app(app, db)
# Add Flask-Admin views for Users and Roles
admin.init_app(app)
ckeditor.init_app(app)
admin.add_view(UserAdmin(User, db.session))
admin.add_view(RoleAdmin(Role, db.session))
admin.add_view(PostAdmin(Post, db.session))
def create_app(env='dev'):
app = Flask(__name__)
app.config.from_object(get_config(env))
db.init_app(app)
mail.init_app(app)
app.register_blueprint(user_blueprint)
app.register_blueprint(book_blueprint)
app.register_blueprint(library_blueprint)
app.register_blueprint(home_page)
db.create_all(app=app)
migrate.init_app(app, db)
return app
def extensions(app):
"""
Register 0 or more extensions (mutates the app passed in).
:param app: Flask application instance
:return: None
"""
debug_toolbar.init_app(app)
mail.init_app(app)
csrf.init_app(app)
db.init_app(app)
login_manager.init_app(app)
return None
def init_extensions(app):
db.init_app(app)
db.app = app
db.metadata.naming_convention = {
"ix": 'ix_%(column_0_label)s',
"uq": "uq_%(table_name)s_%(column_0_name)s",
"ck": "ck_%(table_name)s_%(column_0_name)s",
"fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
"pk": "pk_%(table_name)s"
}
# set constraint naming convention to sensible default, per
# http://docs.sqlalchemy.org/en/rel_0_9/core/constraints.html#configuring-constraint-naming-conventions
assets.init_app(app)
assets.app = app
babel.init_app(app)
cache.init_app(app)
csrf.init_app(app)
mail.init_app(app)
login_manager.init_app(app)
rq.init_app(app)
app.rq = rq
store.init_app(app)
rest.init_app(app,
flask_sqlalchemy_db=db,
preprocessors=restless_preprocessors)
rest.app = app
limiter.init_app(app)
for handler in app.logger.handlers:
limiter.logger.addHandler(handler)
# stable list of admin phone numbers, cached in memory to avoid db hit for each call
# disable in testing
if app.config.get('TESTING', False):
app.ADMIN_PHONES_LIST = []
else:
try:
app.ADMIN_PHONES_LIST = filter(bool, [
str(u.phone.national_number) if u.phone else None
for u in User.query.all()
])
except sqlalchemy.exc.SQLAlchemyError:
# this may throw an error when creating the database from scratch
pass
if app.config.get('DEBUG'):
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
app.debug = True
def configure_extensions(app):
# flask-mongoengine
db.init_app(app)
app.session_interface = MongoEngineSessionInterface(db)
# flask-mail
mail.init_app(app)
# flask-babel
babel.init_app(app)
# Bcrypt for hashing passwords
bcrypt.init_app(app)
# the Gravatar service
gravatar.init_app(app)
# Markdown
md.init_app(app)
# Caching
cache.init_app(app)
# Debug Toolbar
if app.debug:
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
@babel.localeselector
def get_locale():
"""
Get the current request locale.
returns String
"""
if not hasattr(g, 'lang'):
g.lang = 'en'
accept_languages = app.config.get('ACCEPT_LANGUAGES')
return g.lang or request.accept_languages.best_match(accept_languages)
# flask-login
login_manager.login_view = 'frontend.login'
login_manager.refresh_view = 'frontend.reauth'
@login_manager.user_loader
def load_user(user_id):
return User.objects(id=user_id).first()
login_manager.setup_app(app)
def configure_extensions(app):
# flask-mongoengine
db.init_app(app)
app.session_interface = MongoEngineSessionInterface(db)
# flask-mail
mail.init_app(app)
# flask-babel
babel.init_app(app)
# Bcrypt for hashing passwords
bcrypt.init_app(app)
# the Gravatar service
gravatar.init_app(app)
# Markdown
md.init_app(app)
# Caching
cache.init_app(app)
# Debug Toolbar
if app.debug:
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
@babel.localeselector
def get_locale():
"""
Get the current request locale.
returns String
"""
if not hasattr(g, 'lang'):
g.lang = 'en'
accept_languages = app.config.get('ACCEPT_LANGUAGES')
return g.lang or request.accept_languages.best_match(accept_languages)
# flask-login
login_manager.login_view = 'frontend.login'
login_manager.refresh_view = 'frontend.reauth'
@login_manager.user_loader
def load_user(user_id):
return User.objects(id=user_id).first()
login_manager.setup_app(app)
def configure_extensions(app):
from extensions import cache, db, mail, Login
# initialize mail
mail = mail.init_app(app)
# initialize cache
cache = cache.init_app(app)
# initialize database
db.init_app(app)
app.logger.info("Database initialized.")
db.app = app
db.metadata.bind = db.get_engine(app)
db.metadata.reflect()
app.logger.info("Database tables reflected.")
from models import User
db.create_all(bind=['users'])
# login
Login.manager.setup_app(app)
@Login.manager.user_loader
def load_user(userid):
return User.query.get(userid)
@Login.manager.token_loader
def load_token(token):
return User.query.filter(User.passkey == token).first()
def create_app(config_file='app_config.py'):
app = Flask(__name__)
app.config.from_pyfile(config_file)
ckeditor.init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
search.init_app(app)
gravatar.init_app(app)
csrf_protection.init_app(app)
flask_api.init_app(app)
@login_manager.user_loader
def load_user(user_id):
requested_user = User.query.get(user_id)
return requested_user
app.register_blueprint(home)
app.register_blueprint(post)
app.register_blueprint(comment)
app.register_blueprint(search_routing)
app.register_blueprint(about_routing)
app.register_blueprint(verification)
app.register_blueprint(user_operations)
app.register_blueprint(api)
app.register_blueprint(contact_routing)
app.register_blueprint(notification_routing)
app.register_blueprint(reply)
app.register_blueprint(website_settings)
app.register_blueprint(login_system)
app.register_blueprint(newsletter)
app.register_blueprint(twitter_blueprint)
app.register_blueprint(oauth_routing)
app.register_blueprint(github_blueprint)
app.register_blueprint(google_blueprint)
app.register_error_handler(400, bad_request)
app.register_error_handler(403, forbidden)
app.register_error_handler(404, not_found)
app.register_error_handler(500, internal_error)
app.register_error_handler(401, unauthorized)
return app
def register_extensions(self):
cache.init_app(self)
db.init_app(self)
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(self, user_datastore, register_form=ExtendedRegisterForm)
mail.init_app(self)
debug_toolbar.init_app(self)
migrate.init_app(self, db)
admin.init_app(self)
@security.context_processor
def security_context_processor():
return dict(
admin_base_template=admin.base_template,
admin_view=admin.index_view,
# h=admin_helpers,
get_url=url_for
)
def create_app():
application = Flask(__name__)
application.config.update(settings)
mail.init_app(application)
mongo.init_app(application)
cache.init_app(application)
jwt.init_app(application)
limiter.init_app(application)
for bp in http_blueprints:
import_module(bp.import_name)
application.register_blueprint(bp)
application.cli.add_command(populate_users_command)
application.cli.add_command(populate_transactions_command)
return application
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
celery.config_from_object(app.config)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
flask_admin.init_app(app)
configure_uploads(app, photos)
patch_request_class(app)
flask_admin.add_view(PostModelView(Post, db.session, name='博文管理'))
flask_admin.add_view(UserModelView(User, db.session, name='用户管理'))
flask_admin.add_view(RoleModelView(Role, db.session, name='身份管理'))
path = os.path.join(os.path.dirname(__file__), 'static')
flask_admin.add_view(MyFileAdmin(path, '/static', name='文件管理'))
handler = logging.FileHandler('flask_error.log', encoding='UTF-8')
handler.setLevel(logging.DEBUG)
logging_format = logging.Formatter(
'%(asctime)s - %(levelname)s - %(filename)s - %(funcName)s - %(lineno)s - %(message)s')
handler.setFormatter(logging_format)
app.logger.addHandler(handler)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .api_1_0 import api as api_1_0_blueprint
app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')
from .pic import pic as pic_blueprint
app.register_blueprint(pic_blueprint, url_prefix='/pic')
return app
def configure_extensions(app):
pages.init_app(app)
bootstrap.init_app(app)
app.config["BOOTSTRAP_SERVE_LOCAL"] = True
db.init_app(app)
app.config["db"] = db
login_manager.init_app(app)
app.config['ext_login_manager'] = login_manager
configure_identity(app)
moment.init_app(app)
mail.init_app(app)
app.config['ext_mail'] = mail
sendmail.init_app(app)
app.config['contrib_sendmail'] = sendmail
def register_extensions(app):
cache.init_app(app)
db.init_app(app)
admin.init_app(app)
register_admin_views(admin)
user_datastore = MongoEngineUserDatastore(db, User, Role)
security = Security(app, user_datastore, register_form=ExtendedRegisterForm)
mail.init_app(app)
# socketio.init_app(app)
app.config['DEBUG_TB_PANELS'] = ['flask.ext.mongoengine.panels.MongoDebugPanel',
'flask_debugtoolbar.panels.versions.VersionDebugPanel',
'flask_debugtoolbar.panels.timer.TimerDebugPanel',
'flask_debugtoolbar.panels.headers.HeaderDebugPanel',
'flask_debugtoolbar.panels.request_vars.RequestVarsDebugPanel',
'flask_debugtoolbar.panels.config_vars.ConfigVarsDebugPanel',
'flask_debugtoolbar.panels.template.TemplateDebugPanel',
'flask_debugtoolbar.panels.logger.LoggingPanel',
'flask_debugtoolbar.panels.profiler.ProfilerDebugPanel']
debug_toolbar.init_app(app)
return None
def create_app():
app = Flask(__name__)
app.config.from_object(Config)
db.init_app(app)
marshmallow.init_app(app)
migrate.init_app(app, db)
login.init_app(app)
dynaconf.init_app(app)
mail.init_app(app)
moment.init_app(app)
# configurando os blueprints
accounts.configure(app)
errors.configure(app)
feed.configure(app)
users.configure(app)
#image.configure(app)
email.configure(app)
return app
def create_app(self):
# THIS NEEDS TO MIRROR YOUR __init__.py's APP INSTANTIATION
# ... or whatever you need to setup the right test environment
from flaskinni import app
app.config.from_object('settings')
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
register_extensions(app)
# images
configure_uploads(app, uploaded_images)
# sort of like an application factory
db.init_app(app)
security.init_app(app,
user_datastore,
confirm_register_form=ExtendedRegisterForm)
mail.init_app(app)
md = Markdown(app, extensions=['fenced_code', 'tables'])
# migrate.init_app(app, db)
# Add Flask-Admin views for Users and Roles
admin.init_app(app)
admin.add_view(UserAdmin(User, db.session))
admin.add_view(RoleAdmin(Role, db.session))
admin.add_view(PostAdmin(Post, db.session))
def configure_extensions(app):
# flask-babel
babel = Babel(app)
@babel.localeselector
def get_locale():
accept_languages = app.config.get('ACCEPT_LANGUAGES')
return request.accept_languages.best_match(accept_languages)
# flask-sqlalchemy
db.init_app(app)
# flask-mail
mail.init_app(app)
#mongo db
mongo.init_app(app)
# flask-cache
cache.init_app(app)
# flask-login
login_manager.login_view = 'frontend.login'
login_manager.refresh_view = 'frontend.reauth'
@login_manager.user_loader
def load_user(id):
return User.query.get(id)
login_manager.init_app(app)
# flask-openid
oid.init_app(app)
# init debug toolbar
toolbar = DebugToolbarExtension(app)
init_extensions(app)
def configure_extensions(app):
db.init_app(app)
login_manager.init_app(app)
mail.init_app(app)
def register_extensions(app):
"""Register all extensions."""
login_manager.init_app(app)
debug_toolbar.init_app(app)
mail.init_app(app)
def create_app(name=None, config=None):
effective_name = name if name else __name__
app = Flask(
effective_name,
template_folder=os.path.join(FLASK_APP_DIR, '..', 'templates'),
static_folder=os.path.join(FLASK_APP_DIR, '..', 'static')
)
# Config
effective_config = config or 'flask_application.config.app_config'
app.config.from_object(effective_config)
app.logger.info("Config: %s; DB: %s" % (app.config['ENVIRONMENT'], app.config['SQLALCHEMY_DATABASE_URI']))
# Logging
import logging
logging.basicConfig(
level=app.config['LOG_LEVEL'],
format='%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]',
datefmt='%Y%m%d-%H:%M%p',
)
# Email on errors
if not app.debug:
import logging.handlers
mail_handler = logging.handlers.SMTPHandler(
'localhost',
os.getenv('USER'),
app.config['SYS_ADMINS'],
'{0} error'.format(app.config['SITE_NAME']),
)
mail_handler.setFormatter(logging.Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''.strip()))
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
app.logger.info("Emailing on error is ENABLED")
else:
app.logger.info("Emailing on error is DISABLED")
# Bootstrap
from flask_bootstrap import Bootstrap
Bootstrap(app)
# Assets
from flask.ext.assets import Environment
app.assets = Environment(app)
# Ensure output directory exists
assets_output_dir = os.path.join(FLASK_APP_DIR, '..', 'static', 'gen')
if not os.path.exists(assets_output_dir):
os.mkdir(assets_output_dir)
# Email
mail.init_app(app)
app.mail = mail
# Memcache
cache.init_app(app)
app.cache = cache
# Business Logic
# http://flask.pocoo.org/docs/patterns/packages/
# http://flask.pocoo.org/docs/blueprints/
from flask_application.controllers.frontend import frontend
app.register_blueprint(frontend)
# SQLAlchemy
db.init_app(app)
app.db = db
from flask.ext.security import SQLAlchemyUserDatastore
from flask_application.models import User, Role
from flask_application.ext.flask_security import ExtendedLoginForm
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
app.user_datastore = user_datastore
security.init_app(app=app, datastore=user_datastore, login_form=ExtendedLoginForm)
app.security = security
from flask_application.controllers.admin import admin
app.register_blueprint(admin)
# REST
from flask.ext.restful import Api
app.api = Api(app)
# TODO
from flask_application.controllers.todo import todo_blueprint
app.register_blueprint(todo_blueprint)
from flask_application.controllers.todo import TodoResource
app.api.add_resource(TodoResource, '/api/todo', '/api/todo/<int:todo_id>')
from werkzeug.contrib.fixers import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)
if app.config['SETUP_DB']:
with app.app_context():
app.db.drop_all()
app.db.create_all()
from flask_application.populate import populate_data
populate_data(app)
return app
def configure_extensions(app):
# flask-mongoengine
db.init_app(app)
app.session_interface = MongoEngineSessionInterface(db)
# flask-mail
mail.init_app(app)
# flask-babel
babel.init_app(app)
# Bcrypt for hashing passwords
bcrypt.init_app(app)
# the Gravatar service
gravatar.init_app(app)
# Markdown
md.init_app(app)
# Caching
cache.init_app(app)
# Debug Toolbar
if app.debug and app.config['DEBUG_TB_PROFILER_ENABLED']:
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
@babel.localeselector
def get_locale():
"""
Get the current request locale.
returns String
"""
if not hasattr(g, 'lang'):
g.lang = app.config.get('BABEL_DEFAULT_LOCALE')
accept_languages = app.config.get('ACCEPT_LANGUAGES')
# Try to guess the language from the user accept
# header the browser transmits. We support ar/fr/en,
# The best match wins.
g.lang = session.get('language', None) or \
request.accept_languages.best_match(accept_languages) or \
g.lang
if g.lang == 'ar':
g.lang_dir = 'rtl'
g.layout_dir_class = 'right-to-left'
g.language_name = u'العربية'
else:
g.lang_dir = 'ltr'
g.layout_dir_class = 'left-to-right'
g.language_name = 'English' if g.lang == 'en' else u'Français'
return g.lang
# flask-login
login_manager.login_view = 'frontend.login'
login_manager.refresh_view = 'frontend.reauth'
@login_manager.user_loader
def load_user(user_id):
return User.objects(id=user_id).first()
login_manager.setup_app(app)
import time, datetime
from datetime import timedelta
import os
from os import path
from werkzeug import secure_filename # for uploading files
from flask_mail import Mail
import pymssql
app = Flask(__name__)
app.config.from_object('config')
app.register_blueprint(controllers.main, url_prefix='/cloud')
app.register_blueprint(controllers.data, url_prefix='/cloud')
app.register_blueprint(controllers.user, url_prefix='/cloud')
mysql.init_app(app)
mail.init_app(app)
# set the secret key. keep this really secret:
app.secret_key = os.urandom(24)
if __name__ == "__main__":
app.run(debug=True)
def create_app(app_config):
app = Flask(__name__)
app.config.from_object(app_config)
# create a fake MarathonInfo if one doesn't exist
# just enough to bootstrap
info = db.session.query(MarathonInfo).first()
if not info:
now = datetime.datetime.now()
half_an_hour_earlier = now - datetime.timedelta(minutes=30)
half_an_hour_later = now + datetime.timedelta(minutes=30)
test_game = Game.create(name='Test Game', developer='Test Dev')
test_play = ScheduleEntry.create(
title='Play The Test Game',
game_id=test_game.id,
start=half_an_hour_earlier,
end=half_an_hour_later
)
MarathonInfo.create(
start=(now - datetime.timedelta(hours=10)),
hours=31,
total=12345.67,
current_game_id=test_game.id,
next_game_id=test_game.id,
current_schedule_entry=test_play.id
)
__location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__)))
try: # dev
with open(os.path.join(__location__, 'secrets.json')) as secrets_file:
secrets = json.load(secrets_file)
app.secret_key = secrets.get('app_secret')
app_config.SECRET_KEY = app.secret_key
app.config.update(
MAIL_SERVER='smtp.gmail.com',
MAIL_PORT=465,
MAIL_USERNAME='******',
MAIL_DEFAULT_SENDER='*****@*****.**',
MAIL_PASSWORD=secrets.get("email_password"),
MAIL_USE_SSL=True,
MAIL_USE_TLS=False
)
except IOError: # prod
app.secret_key = os.environ.get('IGG_APP_SECRET')
app_config.SECRET_KEY = app.secret_key
app.config.update(
MAIL_SERVER='smtp.gmail.com',
MAIL_PORT=465,
MAIL_USERNAME='******',
MAIL_DEFAULT_SENDER='*****@*****.**',
MAIL_PASSWORD=os.environ.get("IGG_EMAIL_PASSWORD"),
MAIL_USE_SSL=True,
MAIL_USE_TLS=False
)
login_manager.login_view = 'login.show'
admin.add_view(AdminModelView(Challenge, db.session, endpoint='challengeadmin'))
admin.add_view(AdminModelView(Game, db.session))
admin.add_view(AdminModelView(MarathonInfo, db.session))
admin.add_view(AdminModelView(Prize, db.session))
admin.add_view(AdminModelView(Interview, db.session))
admin.add_view(AdminModelView(ScheduleEntry, db.session))
admin.add_view(AdminModelView(User, db.session))
admin.add_view(AdminModelView(Crew, db.session))
admin.add_view(ImageView(Image, db.session))
login_manager.init_app(app)
admin.init_app(app)
mail.init_app(app)
register_routes(app)
@app.errorhandler(404)
def page_not_found(e):
return render_template('404.tmpl'), 404
@login_manager.user_loader
def load_user(id):
return db.session.query(User).filter_by(id=id).first()
@app.context_processor
def inject_marathon_info():
marathon_info = getattr(g, "marathon_info", None)
if not marathon_info:
marathon_info = g.marathon_info = db.session.query(MarathonInfo).first()
current_game = db.session.query(Game).filter_by(id=marathon_info.current_game_id).first()
return dict(marathon_info=marathon_info, current_game=current_game)
return app
def configure_extensions(app):
"""配置拓展程序，数据库db、缓存cache、邮件mail"""
# configure extensions
db.init_app(app)
cache.init_app(app)
mail.init_app(app)
def register_extensions(app):
mail.init_app(app)
