def init_app(self, app): self.app = app self.jwt.init_app(app) self.blueprint = Blueprint( 'tilda_center', __name__, template_folder='templates', static_folder='static', static_url_path='/static/tilda_center', ) self.app.register_blueprint(self.blueprint) from api import api_v0, api self.api = api self.app.register_blueprint(api_v0) self.app.register_blueprint(apidoc.apidoc) self.cors = CORS(self.app, resources=self.app.config['CORS_RESOURCES']) self.db = Database(self.app) self.user_datastore = PeeweeUserDatastore( self.db, User, Role, UserRoles, ) self.security.init_app( self.app, self.user_datastore, ) self.admin.init_app(self.app)
def create_app(config, app=None): if app is None: app = Flask(__name__) app.config.from_object(config) @app.route('/media/<path:path>') def send_media(path): fullPath = f"../{app.config['MEDIA_PATH']}/{path}" try: return send_file(fullPath) except FileNotFoundError: return 'No such file', 404 app.sendmail = lambda to, message: sm(app.config, to, message) app.collect = Collect(app) db.init_app(app) app.db = db from .models.user import User from .models.role import Role, UserRoles app.user_datastore = PeeweeUserDatastore( app.db, User, Role, UserRoles, ) app.security = Security(app, app.user_datastore) app.jwt = JWTManager(app) create_api(app) app.cors = CORS(app, supports_credentials=True) cli.register(app) return app
def create_app(config, app=None): class Result(object): def __init__(self, **kwargs): for k, v in kwargs.items(): setattr(self, k, v) if app is None: app = Flask(__name__) app.config.from_object(config) app.collect = Collect(app) db.init_app(app) app.db = db from .models.auth import User, Role, UserRoles app.user_datastore = PeeweeUserDatastore( app.db, User, Role, UserRoles, ) app.security = Security(app, app.user_datastore) app.jwt = JWTManager(app) create_api(app) return app
def create_app(config, app=None): class Result(object): def __init__(self, **kwargs): for k, v in kwargs.items(): setattr(self, k, v) if app is None: app = Flask(__name__) app.config.from_object(config) app.collect = Collect(app) db.init_app(app) app.db = db app.blueprint = Blueprint( 'app', __name__, template_folder='templates', static_folder='static', static_url_path='/static/app', ) app.register_blueprint(app.blueprint) from .models.auth import User, Role, UserRoles app.user_datastore = PeeweeUserDatastore( app.db, User, Role, UserRoles, ) app.security = Security(app, app.user_datastore) app.jwt = JWTManager(app) create_api(app) return app
def peewee_datastore(request, app, tmpdir): from peewee import TextField, DateTimeField, IntegerField, BooleanField, \ ForeignKeyField from flask_peewee.db import Database f, path = tempfile.mkstemp(prefix='flask-security-test-db', suffix='.db', dir=str(tmpdir)) app.config['DATABASE'] = {'name': path, 'engine': 'peewee.SqliteDatabase'} db = Database(app) class Role(db.Model, RoleMixin): name = TextField(unique=True) description = TextField(null=True) class User(db.Model, UserMixin): email = TextField() username = TextField() password = TextField(null=True) last_login_at = DateTimeField(null=True) current_login_at = DateTimeField(null=True) last_login_ip = TextField(null=True) current_login_ip = TextField(null=True) login_count = IntegerField(null=True) active = BooleanField(default=True) confirmed_at = DateTimeField(null=True) class UserRoles(db.Model): """ Peewee does not have built-in many-to-many support, so we have to create this mapping class to link users to roles.""" user = ForeignKeyField(User, related_name='roles') role = ForeignKeyField(Role, related_name='users') name = property(lambda self: self.role.name) description = property(lambda self: self.role.description) with app.app_context(): for Model in (Role, User, UserRoles): Model.create_table() def tear_down(): db.close_db(None) os.close(f) os.remove(path) request.addfinalizer(tear_down) return PeeweeUserDatastore(db, User, Role, UserRoles)
def create_app(config_filename): from app.models.Role import Role from app.models.Users import Users from app.models.UserRoles import UserRoles from app.models.util import getDB from app.config import loadConfig from app.logic.validation import doesUserHaveRole from app.controllers.admin import admin from app.controllers.public import public app = Flask(__name__) secret_cfg = loadConfig.get_secret_cfg() cfg = loadConfig.get_cfg() app.secret_key = os.environ["APP_SECRET_KEY"] app.register_blueprint(admin) app.register_blueprint(public) mainDB = getDB() user_datastore = PeeweeUserDatastore(mainDB, Users, Role, UserRoles) # app.config["SECURITY_SEND_REGISTER_EMAIL"] = False app.config["SECURITY_PASSWORD_SALT"] = os.environ["SECURITY_PASSWORD_SALT"] security = Security(app, user_datastore) app.jinja_env.globals.update(doesUserHaveRole=doesUserHaveRole) # @app.before_first_request # def create_user(): # user = user_datastore.create_user(email='*****@*****.**',password=utils.encrypt_password('password'),role='admin') # role = user_datastore.create_role(name='admin') # user_datastore.add_role_to_user(user, role) @app.errorhandler(403) def access_denied(e): return render_template('views/403.html', cfg=cfg), 403 @app.errorhandler(404) def pageNotFound(e): return render_template('views/404.html', cfg=cfg), 404 return app
def create_app(config, app=None): if app is None: app = Flask(__name__) app.config.from_object(config) app.collect = Collect(app) db.init_app(app) app.db = db from .models.auth import User, Role, UserRoles app.user_datastore = PeeweeUserDatastore( app.db, User, Role, UserRoles, ) app.security = Security(app, app.user_datastore) app.jwt = JWTManager(app) create_api(app) return app
from flask import Flask from playhouse.flask_utils import FlaskDB from flask_admin import Admin from flask_security import (Security, PeeweeUserDatastore, UserMixin, RoleMixin, login_required) from .config import Config app = Flask(__name__) app.config.from_object(Config) db_wrapper = FlaskDB(app) admin = Admin(app, name='Projekt bazowy', template_mode='bootstrap3') from . import views, models, cli user_datastore = PeeweeUserDatastore(db_wrapper.database, models.User, models.Role, models.UserRoles) security = Security(app, user_datastore)
@app.before_request def before_request(): database.connect() @app.after_request def after_request(response): database.close() return response from databases import MySQL as database user_datastore = PeeweeUserDatastore(database, User, Role, UserRole) security = Security(app, user_datastore) @security.context_processor def security_context_processor(): return dict(h=admin_helpers, get_url=url_for) def run_app(app, log=False, debug=False): if not log: logger = logging.getLogger('werkzeug') logger.disabled = True app.logger.disabled = True
def peewee_setup(request, app, tmpdir, realdburl): from peewee import ( TextField, DateTimeField, IntegerField, BooleanField, ForeignKeyField, CharField, ) from flask_peewee.db import Database if realdburl: engine_mapper = { "postgres": "peewee.PostgresqlDatabase", "mysql": "peewee.MySQLDatabase", } db_url, db_info = _setup_realdb(realdburl) pieces = urlsplit(db_url) db_config = { "name": pieces.path[1:], "engine": engine_mapper[pieces.scheme.split("+")[0]], "user": pieces.username, "passwd": pieces.password, "host": pieces.hostname, } else: f, path = tempfile.mkstemp(prefix="flask-security-test-db", suffix=".db", dir=str(tmpdir)) db_config = {"name": path, "engine": "peewee.SqliteDatabase"} app.config["DATABASE"] = db_config db = Database(app) class Role(db.Model, RoleMixin): name = CharField(unique=True, max_length=80) description = TextField(null=True) class User(db.Model, UserMixin): email = TextField() username = TextField() security_number = IntegerField(null=True) password = TextField(null=True) last_login_at = DateTimeField(null=True) current_login_at = DateTimeField(null=True) tf_primary_method = TextField(null=True) tf_totp_secret = TextField(null=True) tf_phone_number = TextField(null=True) last_login_ip = TextField(null=True) current_login_ip = TextField(null=True) login_count = IntegerField(null=True) active = BooleanField(default=True) confirmed_at = DateTimeField(null=True) class UserRoles(db.Model): """ Peewee does not have built-in many-to-many support, so we have to create this mapping class to link users to roles.""" user = ForeignKeyField(User, backref="roles") role = ForeignKeyField(Role, backref="users") name = property(lambda self: self.role.name) description = property(lambda self: self.role.description) with app.app_context(): for Model in (Role, User, UserRoles): Model.drop_table() Model.create_table() def tear_down(): if realdburl: db.close_db(None) _teardown_realdb(db_info) else: db.close_db(None) os.close(f) os.remove(path) request.addfinalizer(tear_down) return PeeweeUserDatastore(db, User, Role, UserRoles)
from agenda.model import Occurrence, User, Event from flask import Flask, render_template, request from flask_security import PeeweeUserDatastore, Security from flask_mail import Mail from datetime import datetime from instance import settings import locale locale.setlocale(locale.LC_ALL, settings.LOCALE) app = Flask(__name__) from agenda.model import User, Role, UserRole user_datastore = PeeweeUserDatastore(settings.db, User, Role, UserRole) security = Security(app, user_datastore) app.config['MAIL_SERVER'] = settings.MAIL_SERVER app.config['MAIL_PORT'] = settings.MAIL_PORT app.config['MAIL_USE_SSL'] = settings.MAIL_USE_SSL app.config['MAIL_USERNAME'] = settings.MAIL_USERNAME app.config['MAIL_PASSWORD'] = settings.MAIL_PASSWORD mail = Mail(app) @app.context_processor def inject(): return dict(site_title=settings.SITE_TITLE, lang=settings.LOCALE[:2]) import agenda.events import agenda.users
def init_auth(app): user_datastore = PeeweeUserDatastore(database, User, Role, UserRoles) security = Security(app, user_datastore) app.before_first_request(lambda: _init_auth_datastore(user_datastore))
def peewee_setup(request, app, tmpdir, realdburl): pytest.importorskip("peewee") from peewee import ( TextField, DateTimeField, Field, IntegerField, BooleanField, BlobField, ForeignKeyField, CharField, ) from playhouse.flask_utils import FlaskDB if realdburl: engine_mapper = { "postgresql": "peewee.PostgresqlDatabase", "mysql": "peewee.MySQLDatabase", } db_url, db_info = _setup_realdb(realdburl) pieces = urlsplit(db_url) db_config = { "name": pieces.path[1:], "engine": engine_mapper[pieces.scheme.split("+")[0]], "user": pieces.username, "password": pieces.password, "host": pieces.hostname, "port": pieces.port, } else: f, path = tempfile.mkstemp( prefix="flask-security-test-db", suffix=".db", dir=str(tmpdir) ) db_config = {"name": path, "engine": "peewee.SqliteDatabase"} app.config["DATABASE"] = db_config db = FlaskDB(app) class AsaList(Field): field_type = "text" def db_value(self, value): if value: return ",".join(value) return value def python_value(self, value): if value: return value.split(",") return value class BytesBlobField(BlobField): # Alas pydantic/py_webauthn doesn't understand memoryviews def python_value(self, value): if value: return bytes(value) return value class Role(RoleMixin, db.Model): name = CharField(unique=True, max_length=80) description = TextField(null=True) permissions = TextField(null=True) class User(UserMixin, db.Model): email = TextField(unique=True, null=False) fs_uniquifier = TextField(unique=True, null=False) fs_webauthn_user_handle = TextField(unique=True, null=True) username = TextField(unique=True, null=True) security_number = IntegerField(null=True) password = TextField(null=True) last_login_at = DateTimeField(null=True) current_login_at = DateTimeField(null=True) tf_primary_method = TextField(null=True) tf_totp_secret = TextField(null=True) tf_phone_number = TextField(null=True) us_totp_secrets = TextField(null=True) us_phone_number = TextField(null=True) last_login_ip = TextField(null=True) current_login_ip = TextField(null=True) login_count = IntegerField(null=True) active = BooleanField(default=True) confirmed_at = DateTimeField(null=True) class WebAuthn(WebAuthnMixin, db.Model): credential_id = BytesBlobField(unique=True, null=False, index=True) public_key = BytesBlobField(null=False) sign_count = IntegerField(default=0) transports = AsaList(null=True) # a JSON string as returned from registration extensions = TextField(null=True) lastuse_datetime = DateTimeField(null=False) # name is provided by user - we make sure is unique per user name = TextField(null=False) usage = TextField(null=False) # This creates a real column called user_id user = ForeignKeyField(User, backref="webauthn") class UserRoles(db.Model): """Peewee does not have built-in many-to-many support, so we have to create this mapping class to link users to roles.""" user = ForeignKeyField(User, backref="roles") role = ForeignKeyField(Role, backref="users") name = property(lambda self: self.role.name) description = property(lambda self: self.role.description) def get_permissions(self): return self.role.get_permissions() with app.app_context(): for Model in (Role, User, UserRoles, WebAuthn): Model.drop_table() Model.create_table() def tear_down(): if realdburl: db.close_db(None) _teardown_realdb(db_info) else: db.close_db(None) os.close(f) os.remove(path) request.addfinalizer(tear_down) return PeeweeUserDatastore(db, User, Role, UserRoles, WebAuthn)
def create_app(config, app_name, app=None, auth={}, schemas={}): if app is None: app = Flask(__name__) app.config.from_object(config) app.models = f'{app_name}.models' @app.route('/media/<path:path>') def send_media(path): fullPath = f"../{app.config['MEDIA_PATH']}/{path}" try: return send_file(fullPath) except FileNotFoundError: return 'No such file', 404 app.sendmail = lambda to, message: sendmail(app.config, to, message) app.collect = Collect(app) db.init_app(app) app.db = db user_module = auth.get('user', None) if user_module is None: from .models.user import User else: User = import_module(user_module).User role_module = auth.get('role', None) if role_module is None: from .models.role import Role, UserRoles else: role_module_imported = import_module(role_module) Role = role_module_imported.Role UserRoles = role_module_imported.UserRoles app.user_datastore = PeeweeUserDatastore( app.db, User, Role, UserRoles, ) user_module = schemas.get('user', None) if user_module is None: class UserSchema(freenit.schemas.user.BaseUserSchema): pass else: UserSchema = import_module(user_module).UserSchema setattr(freenit.schemas.user, 'UserSchema', UserSchema) PageOutSchema(UserSchema, sys.modules['freenit.schemas.user']) role_module = schemas.get('role', None) if role_module is None: class RoleSchema(freenit.schemas.role.BaseRoleSchema): pass else: RoleSchema = import_module(role_module).RoleSchema setattr(freenit.schemas.role, 'RoleSchema', RoleSchema) PageOutSchema(RoleSchema, sys.modules['freenit.schemas.role']) app.security = Security(app, app.user_datastore) app.jwt = JWTManager(app) create_api(app) app.cors = CORS(app, supports_credentials=True) cli.register(app) return app
logger.warning( 'First run of application, admin password reset required.') # Get ID of new admin user admin_user = user_datastore.get_user('*****@*****.**') login_user(admin_user, False) return redirect(admin_user, '/admin/user/edit/?id={0}'.format(admin_user.id)) ################################ ### SECURITY ### ################################ # Create security datastore logger.debug('Creating security datastore') user_datastore = PeeweeUserDatastore(models.db, User, Role, UserRoles) security = Security(app, user_datastore) # define a context processor for merging flask-admin's template context into the # flask-security views. @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) ################################ ### ADMIN ###
from flask import Flask, render_template, make_response, request, session, redirect, url_for from flask_security import Security, PeeweeUserDatastore, login_required, current_user from forms import * from database import * import psycopg2 import os app = Flask("Twibber") app.config["SECRET_KEY"] = os.environ.get("SECRET_KEY", "insecure dev key") app.config["WTF_CSRF_ENABLED"] = True app.config["SECURITY_USER_IDENTITY_ATTRIBUTES"] = "email" app.config["SECURITY_PASSWORD_HASH"] = "pbkdf2_sha512" app.config["SECURITY_PASSWORD_SALT"] = app.config["SECRET_KEY"] user_datastore = PeeweeUserDatastore(db, User, Role, UserRoles) security = Security(app, user_datastore) @app.route("/") @login_required def index(): return render_template("index.html", user=current_user) @app.route("/register", methods=["GET", "POST"]) def register(): if current_user.is_authenticated: return redirect(url_for('index')) else: register_form = RegisterUser() if register_form.validate_on_submit():
from form import ExtendedRegisterForm from flask_mail import Mail app = Flask(__name__) app.config['DEBUG'] = True SECRET_KEY = os.urandom(32) app.config['SECRET_KEY'] = SECRET_KEY app.config['SECURITY_REGISTERABLE'] = True app.config['SECURITY_REGISTER_URL'] = '/register' app.config['SECURITY_SEND_REGISTER_EMAIL'] = False app.config['SECURITY_PASSWORD_SALT'] = app.config['SECRET_KEY'] user_datastore = PeeweeUserDatastore(database, User, '', '') security = Security(app, user_datastore, register_form=ExtendedRegisterForm) """Creation de la base de données""" @app.cli.command() def initdb(): create_tables() click.echo('Initialisation de la Base de données') """Suppression de la base de données""" @app.cli.command()
def peewee_setup(request, app, tmpdir, realdburl): from peewee import TextField, DateTimeField, IntegerField, BooleanField, \ ForeignKeyField, CharField from flask_peewee.db import Database if realdburl: engine_mapper = { 'postgres': 'peewee.PostgresqlDatabase', 'mysql': 'peewee.MySQLDatabase' } db_url, db_info = _setup_realdb(realdburl) pieces = urlsplit(db_url) db_config = { 'name': pieces.path[1:], 'engine': engine_mapper[pieces.scheme.split('+')[0]], 'user': pieces.username, 'passwd': pieces.password, 'host': pieces.hostname } else: f, path = tempfile.mkstemp(prefix='flask-security-test-db', suffix='.db', dir=str(tmpdir)) db_config = {'name': path, 'engine': 'peewee.SqliteDatabase'} app.config['DATABASE'] = db_config db = Database(app) class Role(db.Model, RoleMixin): name = CharField(unique=True, max_length=80) description = TextField(null=True) class User(db.Model, UserMixin): email = TextField() username = TextField() security_number = IntegerField(null=True) password = TextField(null=True) last_login_at = DateTimeField(null=True) current_login_at = DateTimeField(null=True) last_login_ip = TextField(null=True) current_login_ip = TextField(null=True) login_count = IntegerField(null=True) active = BooleanField(default=True) confirmed_at = DateTimeField(null=True) class UserRoles(db.Model): """ Peewee does not have built-in many-to-many support, so we have to create this mapping class to link users to roles.""" user = ForeignKeyField(User, related_name='roles') role = ForeignKeyField(Role, related_name='users') name = property(lambda self: self.role.name) description = property(lambda self: self.role.description) with app.app_context(): for Model in (Role, User, UserRoles): Model.create_table() def tear_down(): if realdburl: db.close_db(None) _teardown_realdb(db_info) else: db.close_db(None) os.close(f) os.remove(path) request.addfinalizer(tear_down) return PeeweeUserDatastore(db, User, Role, UserRoles)
def create_app(config, app=None): class Result(object): def __init__(self, **kwargs): for k, v in kwargs.items(): setattr(self, k, v) if app is None: app = Flask(__name__) app.config.from_object(config) app.admin = Admin( name='App', # base_template='admin_master.html', template_mode='bootstrap3', index_view=AdminIndexView( # template='admin/my_index.html', ), ) app.collect = Collect() app.db = Peewee(app) db.db = app.db app.blueprint = Blueprint( 'app', __name__, template_folder='templates', static_folder='static', static_url_path='/static/app', ) app.register_blueprint(app.blueprint) from api import api_v0, api app.api = api app.register_blueprint(api_v0) app.register_blueprint(apidoc.apidoc) from .models.auth import User, Role, UserRoles app.user_datastore = PeeweeUserDatastore( app.db, User, Role, UserRoles, ) app.security = Security(app, app.user_datastore) app.admin.init_app(app) def authenticate(username, password): try: user = User.get(email=username) except User.DoesNotExist: return None result = Result( id=user.id, email=user.email, ) if verify_password(password, user.password): return result def identity(payload): try: user = User.get(id=payload['identity']) except User.DoesNotExist: user = None return user app.jwt = JWT(app, authenticate, identity) from .api import auth, gallery, event, user return app