def init_app(app, user_datastore, LoginForm):
def load_user(user_id):
return user_datastore.get_user(user_id)
def load_user_from_request(request):
apikey = request.headers.environ.get('HTTP_X_API_KEY', None)
if apikey:
user = user_datastore.find_user(apikey=apikey)
if not user:
return None
else:
auth = request.headers.get('Authorization')
if not auth or auth.count(':') != 1:
return None
login, password = auth.split(':')
user = user_datastore.find_user(email=login.strip())
if user is None:
return None
if not verify_and_update_password(password.strip(), user):
return None
return user if login_user(user) else None
security = Security()
security.init_app(app, user_datastore, login_form=LoginForm)
app.login_manager.request_loader(load_user_from_request)
app.login_manager.user_loader(load_user)
user_logged_out.connect(invalidate_user)
def init_app(app):
security = Security()
security.init_app(app, user_datastore, login_form=LoginForm)
app.login_manager.request_loader(load_user_from_request)
app.login_manager.user_loader(load_user)
user_logged_out.connect(invalidate_user)
user_logged_in.connect(invalidate_user)
def create_app(config=None):
app = Flask(__name__)
# load configuration
if config:
app.config.from_object(config)
else:
app.config.from_object('rhiz.config.Default')
app.config.from_envvar('RHIZ_APPLICATION_SETTINGS')
security = Security()
security.init_app(app, user_datastore)
assets.init_app(app)
db.init_app(app)
admin.init_app(app)
mail = Mail()
mail.init_app(app)
feature_flag = FeatureFlag()
feature_flag.init_app(app)
# register routes
register_blog_routes(app)
return app
def create_app():
app = flask.Flask(__name__)
app.config.from_object('config')
init_db(app)
api.init_app(app)
security = Security()
security.init_app(app, users)
principals = Principal()
principals.init_app(app)
configure_uploads(app, logos)
from app.views import menu, bp
menu.init_app(app)
app.register_blueprint(bp)
if False:
login_manager = LoginManager(app)
@login_manager.request_loader
def load_user_from_request(request):
if request.authorization:
email, password = request.authorization.username, request.authorization.password
user = User.query.filter_by(email=unicode(email)).first()
if user is not None:
if verify_password(password, user.password):
return user
@identity_loaded.connect_via(app)
def on_identity_loaded(sender, identity):
if not isinstance(identity, AnonymousIdentity):
identity.provides.add(UserNeed(identity.id))
for role in current_user.roles:
identity.provides.add(RoleNeed(role.name))
@principals.identity_loader
def read_identity_from_flask_login():
if current_user.is_authenticated():
return Identity(current_user.id)
return AnonymousIdentity()
return app
def create_app():
app = flask.Flask(__name__)
app.config.from_object('config')
init_db(app)
api.init_app(app)
security = Security()
security.init_app(app, users)
principals = Principal()
principals.init_app(app)
configure_uploads(app, logos)
from app.views import menu, bp
menu.init_app(app)
app.register_blueprint(bp)
if False:
login_manager = LoginManager(app)
@login_manager.request_loader
def load_user_from_request(request):
if request.authorization:
email, password = request.authorization.username, request.authorization.password
user = User.query.filter_by(email=unicode(email)).first()
if user is not None:
if verify_password(password, user.password):
return user
@identity_loaded.connect_via(app)
def on_identity_loaded(sender, identity):
if not isinstance(identity, AnonymousIdentity):
identity.provides.add(UserNeed(identity.id))
for role in current_user.roles:
identity.provides.add(RoleNeed(role.name))
@principals.identity_loader
def read_identity_from_flask_login():
if current_user.is_authenticated():
return Identity(current_user.id)
return AnonymousIdentity()
return app
def init_app(self, app):
if app.config.get('AUTH_DEBUG'):
DebugAuthProvider().init_app(app)
if app.config.get('AUTH_ZOPE'):
ZopeAuthProvider().init_app(app)
app.config.update({
'SECURITY_CONFIRMABLE': True,
'SECURITY_POST_CONFIRM_VIEW': self.homepage,
'SECURITY_PASSWORD_HASH': 'ldap_salted_sha1',
'SECURITY_SEND_PASSWORD_CHANGE_EMAIL': False,
'SECURITY_EMAIL_SUBJECT_REGISTER': (
"Please confirm your email address for "
"the Biological Diversity website"
),
'SECURITY_MSG_EMAIL_CONFIRMED': (
("Your email has been confirmed. You can now log in by "
"clicking the link at the top."),
'success',
),
'SECURITY_RECOVERABLE': True,
'SECURITY_RESET_URL': '/auth/recover_password',
'SECURITY_POST_LOGIN_VIEW': self.homepage,
'SECURITY_MSG_PASSWORD_RESET': (
"You have successfully reset your password.",
'success',
),
'SECURITY_FORGOT_PASSWORD_TEMPLATE': 'auth/forgot_password.html',
'SECURITY_RESET_PASSWORD_TEMPLATE': 'auth/reset_password.html',
'SECURITY_PASSWORD_SCHEMES': ['ldap_salted_sha1'],
})
Security.init_app(self.security_ext, app)
security_state = app.extensions['security']
security_state.pwd_context.update(ldap_salted_sha1__salt_size=7)
security_state.forgot_password_form = EeaForgotPasswordForm
app.register_blueprint(auth)
app.jinja_env.globals['AUTH_BLUEPRINT_INSTALLED'] = True
app.jinja_env.filters['ugly_fix'] = ugly_fix
auth.models = self.models
auth.HOMEPAGE = self.homepage
def create_app(**config_overrides):
global security
app = Flask(__name__, template_folder='templates')
app.config.from_object('config')
app.config.update(config_overrides
)
import sys
import logging
app.logger.addHandler(logging.StreamHandler(sys.stdout))
app.logger.setLevel(logging.ERROR)
engine_db.init_app(app)
# setup security
from wsgi import admin_views
def security_context_processor():
return dict(
admin_base_template=admin.base_template,
admin_view=admin.index_view,
h=admin_helpers,
)
from wsgi.authentication_models import User, Role
user_datastore = MongoEngineUserDatastore(engine_db, User, Role)
security = Security(app)
security._state = security.init_app(app, user_datastore)
security.context_processor(security_context_processor)
admin.init_app(app)
app.register_blueprint(frontend)
app.register_blueprint(filters)
from wsgi.api import api
from wsgi.resume_api import resume_api
api.init_app(app)
resume_api.init_app(app)
return app
confirmed_at = db.DateTimeField()
birthdate = db.DateTimeField(required=True)
gender = db.IntField(required=True)
roles = db.ListField(db.ReferenceField(Role), default=[])
gcm = db.ListField(required=False,default=[])
User.ensure_index([('password',ASCENDING)],index_name='password_idx')
User.ensure_index([('mobile',ASCENDING)],index_name='mobile_idx')
User.ensure_index([('name',ASCENDING)],index_name='mobile_idx')
# Setup Flask-Security
user_datastore = MongoEngineUserDatastore(db, User, Role)
#create the system wide security
security = Security()
security.init_app(app,user_datastore)
"""
This section attaches the login manager of the application
"""
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view='login'
login_manager.anonymous_user = AnonymousUser
def configure_login_manager(app):
security = Security(app)
security.init_app(app, UserDataStore)
app.config['SECURITY_LOGIN_URL'] = '/auth/login'
app.config['SECURITY_LOGIN_USER_TEMPLATE'] = 'mod_auth/log_in.html'
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.mail import Mail
from flask.ext.security import Security, SQLAlchemyUserDatastore
from flask.ext.bootstrap import Bootstrap
from flask.ext.moment import Moment
from flask.ext.pagedown import PageDown
app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
bootstrap = Bootstrap(app)
security = Security(app)
moment = Moment(app)
pagedown = PageDown(app)
mail = Mail(app)
from models import User, Role
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security.init_app(
app,
user_datastore,
)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
def make_app():
babel = Babel()
security = Security()
social = Social()
user_datastore = SQLAlchemyUserDatastore(mdl.DB, mdl.User, mdl.Role)
app = Flask(__name__)
@login_failed.connect_via(app)
def auto_add_user(sender, provider, oauth_response):
connection_values = get_connection_values_from_oauth_response(
provider, oauth_response)
email = connection_values['email']
if not email or not email.strip():
email = ''
if provider.name.lower() == 'facebook':
fname = connection_values['full_name']
email = fb.get_email(oauth_response)
elif provider.name.lower() == 'twitter':
fname = connection_values['display_name'][1:] # cut off leading @
else:
fname = connection_values['display_name']
user = user_datastore.create_user(
email=email,
name=fname,
active=True,
confirmed_at=datetime.now(),
)
role_query = mdl.DB.session.query(mdl.Role).filter_by(
name='authenticated')
try:
role = role_query.one()
except NoResultFound:
role = mdl.Role(name='authenticated')
user.roles.append(role)
user_datastore.commit()
connection_values['user_id'] = user.id
connect_handler(connection_values, provider)
login_user(user)
mdl.DB.session.commit()
flash(gettext(
'Successfully linked login with {}. '
'Ignore the message saying: "{}"').format(
provider.name, '... account not associated with an existing user'),
'info')
return redirect(url_for('root.profile'))
app.user_datastore = user_datastore
app.localconf = lconf = Config('mamerwiselen', 'lost-tracker',
version='2.0', require_load=True)
app.config['SECRET_KEY'] = lconf.get('app', 'secret_key')
app.config['SQLALCHEMY_DATABASE_URI'] = lconf.get('db', 'dsn')
mdl.DB.init_app(app)
# Social connections
social_connections = {}
_add_social_params(social_connections, 'facebook', app.localconf)
_add_social_params(social_connections, 'twitter', app.localconf)
_add_social_params(social_connections, 'google', app.localconf)
if len(social_connections) < 1:
LOG.error('No Social/OAuth providers defined! Users will not be '
'able to log-in!')
app.config.update(social_connections)
social.init_app(app, SQLAlchemyConnectionDatastore(mdl.DB, mdl.Connection))
security.init_app(app, user_datastore)
app.register_blueprint(COMMENT, url_prefix=COMMENT_PREFIX)
app.register_blueprint(GROUP, url_prefix=GROUP_PREFIX)
app.register_blueprint(PHOTO, url_prefix=PHOTO_PREFIX)
app.register_blueprint(QR, url_prefix=QR_PREFIX)
app.register_blueprint(REGISTRATION, url_prefix=REGISTRATION_PREFIX)
app.register_blueprint(ROOT)
app.register_blueprint(STATION, url_prefix=STATION_PREFIX)
app.register_blueprint(TABULAR, url_prefix=TABULAR_PREFIX)
app.register_blueprint(USER, url_prefix=USER_PREFIX)
babel.init_app(app)
babel.localeselector(get_locale)
return app
def create_app():
app = flask.Flask(__name__)
app.config.from_object("config")
init_db(app)
api.init_app(app)
security = Security()
security.init_app(app, users)
principals = Principal()
principals.init_app(app)
configure_uploads(app, logos)
from app.views import menu, bp
from app.signals import init_signals
init_signals(app)
menu.init_app(app)
app.register_blueprint(bp)
if False:
login_manager = LoginManager(app)
@login_manager.request_loader
def load_user_from_request(request):
if request.authorization:
email, password = request.authorization.username, request.authorization.password
user = User.query.filter_by(email=unicode(email)).first()
if user is not None:
if verify_password(password, user.password):
return user
@identity_loaded.connect_via(app)
def on_identity_loaded(sender, identity):
if not isinstance(identity, AnonymousIdentity):
identity.provides.add(UserNeed(identity.id))
for role in current_user.roles:
identity.provides.add(RoleNeed(role.name))
@principals.identity_loader
def read_identity_from_flask_login():
if current_user.is_authenticated():
return Identity(current_user.id)
return AnonymousIdentity()
@app.after_request
def somefunc(response):
if "cid" not in flask.request.cookies:
cid = str(uuid.uuid4())
expires = datetime.datetime.now() + datetime.timedelta(days=365 * 2)
response.set_cookie("cid", cid, expires=expires)
return response
return app
def create_app(config_name):
app = Flask(__name__)
env = Environments(app, default_env=config_name)
if os.path.exists(os.path.join(basedir, 'config_local.yml')):
env.from_yaml(os.path.join(basedir, 'config_local.yml'))
else:
env.from_yaml(os.path.join(basedir, 'config.yml'))
# Uses REDIS_URL from config.yml to set the connection to the redis-server
cache.config = {
'CACHE_TYPE': 'redis',
'CACHE_REDIS_URL': app.config['REDIS_URL']}
# Adding logging capabilities.
if app.config['LOGGING'] is True:
import logging
logger = logging.getLogger('replicate')
logger.setLevel(logging.DEBUG)
log_directory = basedir + app.config['LOG_FILE_PTAH']
log_filename = log_directory + app.config['LOG_FILE']
if not os.path.exists(os.path.dirname(log_filename)):
os.makedirs(os.path.dirname(log_filename))
file_handler = logging.FileHandler(log_filename, mode='a+')
stream_handler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(process)d - %(name)s - ' +
'%(module)s:%(lineno)d - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
stream_handler.setFormatter(formatter)
app.logger.addHandler(file_handler)
# app.logger.addHandler(stream_handler)
app.logger.setLevel(logging.DEBUG)
app.logger.info('Application Process Started')
# SSL
if not app.debug and not app.testing and app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
# handle proxy server headers
from werkzeug.contrib.fixers import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)
db.init_app(app)
login_manager.init_app(app)
cache.init_app(app)
csrf.init_app(app)
redis_store.init_app(app)
cors.init_app(app)
# Flask-Security Init
from ooiservices.app.models import User, Role
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
security.init_app(app, register_blueprint=False)
from ooiservices.app.main import api as main_blueprint
app.register_blueprint(main_blueprint)
from ooiservices.app.uframe import uframe as uframe_blueprint
app.register_blueprint(uframe_blueprint, url_prefix='/uframe')
from ooiservices.app.redmine import redmine as redmine_blueprint
app.register_blueprint(redmine_blueprint, url_prefix='/redmine')
from ooiservices.app.alfresco import alfresco as alfresco_blueprint
app.register_blueprint(alfresco_blueprint, url_prefix='/alfresco')
from ooiservices.app.m2m import m2m as m2m_blueprint
app.register_blueprint(m2m_blueprint, url_prefix='/m2m')
# If debug is enabled add route for site-map
if app.config['DEBUG']:
app.add_url_rule('/site-map', 'site_map', site_map)
return app