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 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 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
