def pony_setup(request, app, tmpdir, realdburl): from pony.orm import Database, Optional, Required, Set from pony.orm.core import SetInstance SetInstance.append = SetInstance.add db = Database() class Role(db.Entity): name = Required(str, unique=True) description = Optional(str, nullable=True) users = Set(lambda: User) class User(db.Entity): email = Required(str) username = Optional(str) security_number = Optional(int) password = Optional(str, nullable=True) last_login_at = Optional(datetime) current_login_at = Optional(datetime) tf_primary_method = Optional(str, nullable=True) tf_totp_secret = Optional(str, nullable=True) tf_phone_number = Optional(str, nullable=True) last_login_ip = Optional(str) current_login_ip = Optional(str) login_count = Optional(int) active = Required(bool, default=True) confirmed_at = Optional(datetime) roles = Set(lambda: Role) def has_role(self, name): return name in {r.name for r in self.roles.copy()} if realdburl: db_url, db_info = _setup_realdb(realdburl) pieces = urlsplit(db_url) db.bind( provider=pieces.scheme.split("+")[0], user=pieces.username, password=pieces.password, host=pieces.hostname, database=pieces.path[1:], ) else: app.config["DATABASE"] = { "name": ":memory:", "engine": "pony.SqliteDatabase" } db.bind("sqlite", ":memory:", create_db=True) db.generate_mapping(create_tables=True) def tear_down(): if realdburl: _teardown_realdb(db_info) request.addfinalizer(tear_down) return PonyUserDatastore(db, User, Role)
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=None, debug=True): app = create_base_app(config, debug) app.config['DATABASE'] = { 'name': 'example2.db', '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() password = TextField() 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) class Connection(db.Model): user = ForeignKeyField(User, related_name='connections') provider_id = TextField() provider_user_id = TextField() access_token = TextField() secret = TextField(null=True) display_name = TextField() full_name = TextField() profile_url = TextField() image_url = TextField() rank = IntegerField(null=True) app.security = Security(app, PeeweeUserDatastore(db, User, Role, UserRoles)) app.social = Social(app, PeeweeConnectionDatastore(db, Connection)) @app.before_first_request def before_first_request(): for Model in (Role, User, UserRoles, Connection): Model.drop_table(fail_silently=True) Model.create_table(fail_silently=True) populate_data() app.get_user = lambda: User.select().get() return app
def init(app): app.register_blueprint(peewee_user_plugin) db = Database(app) DATABASE_PROXY.initialize(db.database) User.create_table(True) # add cli commands app.manager.add_command("import-json-users", CMDImportJSONUsers(app.users)) app.users = PeeweeUsersManager()
def flaskr_client(context, *args, **kwargs): APP.config['DATABASE'] = {'engine': 'peewee.SqliteDatabase', 'name': ':memory:'} # context.db, APP.config['DATABASE'] = tempfile.mkstemp() APP.testing = True context.client = APP.test_client() with APP.app_context(): DB = Database(APP) init_models(DB) # pass yield context.client
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 setUp(self): self.app = Flask(__name__) self.app.config.update( DEBUG=True, TESTING=True, DATABASE={ 'name': 'test.db', 'engine': 'peewee.SqliteDatabase', }, ) self.app.db = Database(self.app) tmp = Feedloggr(self.app, self.app.db) drop_tables(fail_silently=True) create_tables(fail_silently=False) self.url = tmp.blueprint.url_prefix self.client = self.app.test_client()
def create_app(config, **kwargs): app = create_base_app(config) app.config['DATABASE'] = { 'name': 'peewee.db', '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() 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) @app.before_first_request def before_first_request(): for Model in (Role, User, UserRoles): Model.drop_table(fail_silently=True) Model.create_table() populate_data(app.config.get('USER_COUNT', None)) app.security = Security(app, datastore=PeeweeUserDatastore(db, User, Role, UserRoles), **kwargs) add_context_processors(app.security) return app
def create_app(): app = Flask(__name__) app.config.update( DEBUG=True, SECRET_KEY='supersecret', DATABASE={ 'name': 'example.db', 'engine': 'peewee.SqliteDatabase', }, ) app.db = Database(app) Feedloggr(app, app.db) # OPTIONALLY SETUP BEGINS # Simple authentication for the admin interface app.auth = Auth(app, app.db) app.auth.User.create_table(fail_silently=True) # Try to create a new admin user, but fail silently if it already exists try: user = app.auth.User.create( username='******', email='.', password='', admin=True, active=True, ) except PIE: pass else: user.set_password('admin') user.save() # Initialize the admin interface app.admin = Admin(app, app.auth) app.auth.register_admin(app.admin) # Register the feedloggr feeds model app.admin.register(feedloggr_Feeds, feedloggr_FeedsAdmin) app.admin.setup() # OPTIONALLY SETUP ENDS return app
def pony_datastore(request, app, tmpdir): from pony.orm import Database, Optional, Required, Set from pony.orm.core import SetInstance SetInstance.append = SetInstance.add db = Database() class Role(db.Entity): name = Required(str, unique=True) description = Optional(str, nullable=True) users = Set(lambda: User) class User(db.Entity): email = Required(str) username = Optional(str) password = Optional(str, nullable=True) last_login_at = Optional(datetime) current_login_at = Optional(datetime) last_login_ip = Optional(str) current_login_ip = Optional(str) login_count = Optional(int) active = Required(bool, default=True) confirmed_at = Optional(datetime) roles = Set(lambda: Role) def has_role(self, name): return name in {r.name for r in self.roles.copy()} app.config['DATABASE'] = { 'name': ':memory:', 'engine': 'pony.SqliteDatabase' } db.bind('sqlite', ':memory:', create_db=True) db.generate_mapping(create_tables=True) return PonyUserDatastore(db, User, Role)
def create_db(app): db = Database(app) return db
# -*- coding: utf-8 -*- """ Database management and base model using Peewee <https://github.com/coleifer/peewee> as ORM. Actually we just use Flask-Peewee <https://github.com/coleifer/flask-peewee>. """ from app import app from flask_peewee.db import Database # # Database backend (Flask-Peewee). # # Note: It gets the database backend and name from the app configuration. # database = Database(app) db = database.database # # Base model and models management. # class BaseModel(database.Model): """Base model for the selected database backend.""" pass
def __init__(self, app): self.db = Database(app)
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)
def init_app(self, app): # Инициируем работу с БД self.extension = Database(app.web_app)
from flask_peewee.db import Database from FoxRain import FR_APP FR_DATABASE = Database(FR_APP)
from flask import Flask from flask_bootstrap import Bootstrap from flask_peewee.db import Database from common.config import CONFIG from common.models import init_db, DATABASE from web import TEMPLATE_FOLDER from web.utils.json import JSONEncoder init_db(CONFIG.db) app = Flask('app', template_folder=TEMPLATE_FOLDER) Bootstrap(app) app.json_encoder = JSONEncoder db = Database(app, DATABASE)
from flask import Flask # flask-peewee bindings from flask_peewee.db import Database app = Flask(__name__) app.config.from_object('config.Configuration') db = Database(app) def create_tables(): User.create_table() Relationship.create_table() Message.create_table() Note.create_table() @app.template_filter('is_following') def is_following(from_user, to_user): return from_user.is_following(to_user)
from ui.admin import init_admin import local_settings def create_app(): app = Flask(__name__) # Создаем экземпляр класса Flask-приложения app.url_map.strict_slashes = local_settings.TRAILING_SLASH # Указываем игнорирововать слеша в конце url app.config.from_object( local_settings) # Передаём остальные настройки в приложение return app APP = create_app() # Инициируем приложение DB = Database( APP ) # Инициируем работу с БД. Тут же создаюётся таблицы, если их нет в БД. init_models(DB) API = RestAPI(APP) # Инициируем RestAPI от peewee init_api(API) ADMIN = init_admin(APP, DB) # Инициируем Админку import ui.root # Импортируем view для главной страницы # Api на flask_restful и роуты для API from flask_restful import Api api = Api(APP)
"""Copyright (c) 2012 Sergio Gabriel Teves All rights reserved. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. """ """ Created on 29/09/2012 """ from flask import Flask from flask_peewee.db import Database from flask_peewee.auth import Auth from pystatus.settings import Configuration application = Flask(__name__) application.config.from_object(Configuration) db = Database(application) auth = Auth(application, db)
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)
DEBUG = True SECRET_KEY = 'ssshhhh' CSRF_ENABLED = False APP_DIR = 'app' BOOTSTRAP_JQUERY_VERSION = None SOURCES = [] DESTINATIONS = [] """ Load Basic config """ webackup = Flask('modules', static_folder="static", template_folder='templates') webackup.config.from_object(__name__) Bootstrap(webackup) # instantiate the db wrapper db = Database(webackup) # instatiate the login login_manager = LoginManager() login_manager.setup_app(webackup) # initiate scheduler sched = Scheduler() sched.add_jobstore(ShelveJobStore('data/scheduler.db'), 'default') sched.start() """ Registering the blueprint controller """ dirs = os.listdir(APP_DIR) for module in dirs: """ Blueprints """ try: if module.startswith('__'): continue