def setUp(self):
super(SessionTestCase, self).setUp()
self.db_name = "test_db"
self.app.config["MONGODB_DB"] = self.db_name
self.app.config["TESTING"] = True
db = MongoEngine(self.app)
self.app.session_interface = MongoEngineSessionInterface(db)
@self.app.route("/")
def index():
session["a"] = "hello session"
return session["a"]
@self.app.route("/check-session")
def check_session():
return "session: %s" % session["a"]
@self.app.route("/check-session-database")
def check_session_database():
sessions = self.app.session_interface.cls.objects.count()
return "sessions: %s" % sessions
self.db = db
#Import Heroku environment variables
import os
# TODO: Move global inits into its own __init__.py file.
# global variable representing the entire app (Flask object called 'app')
app = Flask(__name__)
assets = Environment(app)
app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY')
app.config['MONGODB_DB'] = os.environ.get('MONGODB_DB')
app.config['MONGODB_HOST'] = os.environ.get('MONGODB_URI')
# PreviousMongoEngine setup
mdb = MongoEngine(app)
app.session_interface = MongoEngineSessionInterface(mdb)
# Flask-Login setup
login_manager = LoginManager()
login_manager.init_app(app)
############################
#### Model Creation ####
############################
# User model defines the fields necessary for login
class User(mdb.Document, UserMixin):
username = mdb.StringField(pk = True)
password = mdb.StringField()
def get_id(self):
return self.username
if isinstance(model, basestring):
classname = model
elif isinstance(model, dict) and 'class' in model:
classname = model['class']
else:
raise ValueError('Unsupported model specifications')
try:
return get_document(classname)
except self.NotRegistered:
message = '{0} does not exists'.format(classname)
raise ValueError(message)
db = UDataMongoEngine()
session_interface = MongoEngineSessionInterface(db)
# Load all core models and mixins
from udata.core.spatial.models import * # noqa
from udata.core.metrics.models import * # noqa
from udata.core.issues.models import * # noqa
from udata.core.badges.models import * # noqa
from udata.core.discussions.models import * # noqa
from udata.core.followers.models import * # noqa
from udata.core.user.models import * # noqa
from udata.core.organization.models import * # noqa
from udata.core.site.models import * # noqa
from udata.core.dataset.models import * # noqa
from udata.core.reuse.models import * # noqa
from udata.core.activity.models import * # noqa
def create_app(config_name):
"""Create an application instance."""
users = [
User(1, 'user1', 'abcxyz'),
User(2, 'user2', 'abcxyz'),
User(3, '3ae0112a-0fe4-11e6-8f2b-b827ebc6c8e4', 'password'),
]
username_table = {u.username: u for u in users}
userid_table = {u.id: u for u in users}
app = Flask(__name__)
# apply configuration
cfg = os.path.join(os.getcwd(), 'config', config_name + '.py')
app.config.from_pyfile(cfg)
# initialize database
app.config['MONGODB_SETTINGS'] = {
'db': 'project1',
'host': '127.0.0.1',
'port': 27017,
# 'username':'******',
# 'password':'******'
}
db.init_app(app)
app.session_interface = MongoEngineSessionInterface(db)
# register blueprints
from .api_v1 import api as api_blueprint
app.register_blueprint(api_blueprint, url_prefix='/api/v1')
app.config['SECRET_KEY'] = 'super-secret'
app.config['JWT_AUTH_URL_RULE'] = '/gettoken'
app.config['JWT_AUTH_USERNAME_KEY'] = 'user'
app.config['JWT_AUTH_PASSWORD_KEY'] = 'pass'
def authenticate(username, password):
user = username_table.get(username, None)
if user and safe_str_cmp(user.password.encode('utf-8'), password.encode('utf-8')):
return user
def identity(payload):
user_id = payload['identity']
return userid_table.get(user_id, None)
jwt = JWT(app, authenticate, identity)
# register an after request handler
@app.after_request
def after_request(rv):
headers = getattr(g, 'headers', {})
rv.headers.extend(headers)
return rv
# authentication token route
# from .auth import auth
# @app.route('/get-auth-token')
# @auth.login_required
# @rate_limit(1, 600) # one call per 10 minute period
# @no_cache
# @json
# def get_auth_token():
# return {'token': g.user.generate_auth_token()}
@app.route('/server-info')
@rate_limit(1, 600) # one call per 10 minute period
@no_cache
@json
def server_info():
return {'server': 'Protype Server'}
return app
def reg_session(app):
app.session_interface = MongoEngineSessionInterface(db)
from flask import Flask, session
from flask_mongoengine import MongoEngine, MongoEngineSessionInterface
from flask_debugtoolbar import DebugToolbarExtension
from datetime import timedelta
# Flask init
app = Flask(__name__)
app.config.from_pyfile('./server.cfg')
# Connection to database init
database = MongoEngine(app)
toolbar = DebugToolbarExtension(app)
app.session_interface = MongoEngineSessionInterface(database)
app.permanent_session_lifetime = timedelta(**app.config['SESSION_LIFETIME'])
# Start server
from route import *
if __name__ == '__main__':
app.run(host=app.config['HOST'], port=app.config['PORT'])
def initialize_db(app):
db.init_app(app)
app.session_interface = MongoEngineSessionInterface(db)
import os
from flask import Flask # etc.
from flask_bcrypt import Bcrypt
from flask_login import LoginManager
from flask_mongoengine import MongoEngine, MongoEngineSessionInterface
# Create and name Flask app
app = Flask("FlaskLoginApp")
# database connection
app.config['MONGODB_SETTINGS'] = {'db': 'flask-login'}
app.config['SECRET_KEY'] = 'dhfdrhrd'
app.debug = os.environ.get('DEBUG', False)
db = MongoEngine(app) # connect MongoEngine with Flask App
app.session_interface = MongoEngineSessionInterface(db) # sessions w/ mongoengine
# Flask BCrypt will be used to salt the user password
flask_bcrypt = Bcrypt(app)
# Associate Flask-Login manager with current app
login_manager = LoginManager()
login_manager.init_app(app)
from flask import Flask
from config import Config
from flask_mongoengine import MongoEngine, MongoEngineSessionInterface
from flask_login import LoginManager
from flask_restplus import Api
from flask_jwt_extended import JWTManager
app = Flask(__name__) #create flask app
app.config.from_object(Config) #load app configuration from Config object
api = Api(app) #api for resources in app
db = MongoEngine(app) #db management
login = LoginManager(app)
app.session_interface = MongoEngineSessionInterface(
db) #database login session
jwt = JWTManager(app)
from app import models, resources
from app.resources import UserLogin, UserRegister, TokenRefresh, UserLogoutAccess, UserLogoutRefresh, UserLogout
@jwt.token_in_blacklist_loader
def check_if_token_in_blacklist(decrypted_token):
jti = decrypted_token['jti']
return models.RevokedToken.is_jti_blacklisted(jti)
#adding resources list into the app api, with its route and class
api.add_resource(UserLogin, '/app/login')
api.add_resource(UserRegister, '/app/register')
api.add_resource(TokenRefresh, '/app/refresh')
api.add_resource(UserLogoutAccess, '/app/logout/access')
def test_session_interface__should_raise_value_error_if_collection_name_not_string(
db, unsupported_value):
with pytest.raises(ValueError) as error:
MongoEngineSessionInterface(db, collection=unsupported_value)
assert str(error.value) == "Collection argument should be string"
def sessison_interface(database):
return MongoEngineSessionInterface(database)
def _conf_session_mongo(app):
'''Flask-MongoEngine'''
from flask_mongoengine import MongoEngineSessionInterface
app.session_interface = MongoEngineSessionInterface(app.db)
def register_database(app):
db.init_app(app)
app.session_interface = MongoEngineSessionInterface(db)
