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
