def create_app():
app = Flask(__name__)
app.config['SECRET_KEY'] = 'thisisyoursecretkeydonttellnoone'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite3'
db.init_app(app)
login_manager = LoginManager()
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
from .models import User
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
return app
def create_app():
app = Flask(__name__)
CORS(app)
app.config['SECRET_KEY'] = 'test'
app.config['SQLALCHEMY_DATABASE_URI'] = f'sqlite:///{db_name}'
db.init_app(app)
from .auth import auth
from .view import view
app.register_blueprint(auth)
app.register_blueprint(view)
from .models import Users, Marks
create_database(app)
login_manager = LoginManager()
login_manager.login_view = 'auth.index'
login_manager.init_app(app)
@login_manager.user_loader
def load_user(id):
return Users.query.get(int(id))
return app
def create_app():
app = Flask(__name__)
app.config["SECRET_KEY"] = "jsahdjashdsdhfafs"
# sql database is being stored in the /website folder
app.config["SQLALCHEMY_DATABASE_URI"] = f"sqlite:///{DB_NAME}"
# initialize the database
db.init_app(app)
# Tell __init__.py that we have blueprints that point to diff url's
from .views import views
from .auth import auth
# Register the blueprints
app.register_blueprint(views, url_prefix="/")
app.register_blueprint(auth, url_prefix="/")
from .models import User, Note
create_database(app)
login_manager = LoginManager()
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
@login_manager.user_loader
def load_user(id):
return User.query.get(int(id))
return app
def create_app():
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret key'
app.config["SQLALCHEMY_DATABASE_URI"] = f"postgresql:///notes"
db.init_app(app)
from .views import views
from .auth import auth
app.register_blueprint(views, url_prefix="/")
app.register_blueprint(auth, url_prefix="/")
from .models import users, Note
create_database(app)
login_manager = LoginManager()
login_manager.login_view = "auth.login"
login_manager.init_app(app)
@login_manager.user_loader
def load_user(id):
return users.query.get(int(id))
return app
def create_app():
"""Create an app."""
app = Flask(__name__.split('.')[0])
# TODO: get this from docker secret /run/secret
app.secret_key = os.urandom(16)
app.config['PREFERRED_URL_SCHEME'] = 'https'
# add user sessions
login_manager.init_app(app)
# add urls
app.register_blueprint(blueprint)
# add CORS to everything under /api/
CORS(app, resources={r'/api/*': {'origins': '*'}})
class JsonCustomEncoder(flask.json.JSONEncoder):
"""encode numpy objects"""
def default(self, obj):
if isinstance(obj, (np.ndarray, np.number)):
return obj.tolist()
elif isinstance(obj, (complex, np.complex)):
return [obj.real, obj.imag]
elif isinstance(obj, set):
return list(obj)
elif isinstance(obj, bytes): # pragma: py3
return obj.decode()
return json.JSONEncoder.default(self, obj)
app.json_encoder = JsonCustomEncoder
return app
def create_app(config_name):
"""An application factory"""
app = Flask(__name__)
app.config.from_object(config[config_name])
db.init_app(app)
migrate.init_app(app, db)
blueprint_registration(app)
api = Api(app)
resource_adding(api)
docs.init_app(app)
register_docs(docs)
bcrypt.init_app(app)
login_manager.init_app(app)
cors.init_app(app, supports_credentials=True)
session.init_app(app)
@login_manager.user_loader
def user_loader(user_id):
# since the user_id is just the primary key of our user table, use it in the query for the user
return User.query.get(int(user_id))
return app
def create_app():
app = Flask(__name__)
app.config['SECRET_KEY'] = 'Flask'
app.config['SQLALCHEMY_DATABASE_URI'] = f'sqlite:///{DB_NAME}'
db.init_app(app)
from .views import views
from .auth import auth
app.register_blueprint(views, url_prefix='/')
app.register_blueprint(auth, url_prefix='/')
from .models import User, Note
create_database(app)
login_manager = LoginManager()
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
@login_manager.user_loader
def load_user(id):
return User.query.get(int(id))
return app
def create_app(config_object):
application = Flask(__name__)
app = application
app.config.from_object(config_object)
db.init_app(app)
login_manager.init_app(app)
principal.init_app(app)
toolbar.init_app(app)
api_create_module(app)
app.register_blueprint(main_blueprint)
app.register_blueprint(measurement_blueprint)
@identity_loaded.connect_via(app)
def on_identity_loaded(sender, identity):
identity.user = current_user
if hasattr(current_user, 'id'):
identity.provides.add(UserNeed(current_user.id))
if hasattr(current_user, 'roles'):
for role in current_user.roles:
identity.provides.add(RoleNeed(role.name))
with app.app_context():
db.create_all()
return app
def create_app(config_file):
app = Flask(__name__)
app.config.from_object(config_file)
app.config.update(
SESSION_COOKIE_SECURE=True,
SESSION_COOKIE_HTTPONLY=True,
SESSION_COOKIE_SAMESITE='Lax',
)
csrf = CSRFProtect(app)
csrf = CSRFProtect()
app.config['SECRET_KEY'] = os.environ.get("CSRF_KEY_SECRET")
app.secret_key = b'\x06\x82\x96n\xfa\xbb(L\x97n\xb8.c\\y\x8a'
login_manager.init_app(app)
csrf.init_app(app)
mail.init_app(app)
app.register_blueprint(router, url='/router')
css = Blueprint(
'css',
__name__,
template_folder='templates',
static_folder='static/css',
static_url_path='/static/css'
)
js = Blueprint(
'js',
__name__,
template_folder='templates',
static_folder='static/js',
static_url_path='/static/js'
)
app.register_blueprint(js)
return app
def create_app():
app = Flask(__name__)
app.register_blueprint(page)
app.userlist = UserList()
app.secret_key = "secret key"
login_manager.init_app(app)
login_manager.login_view = 'page.signup'
return app
def create_app(config_name):
app.config.from_object(configurations[config_name])
from .main import main as main_blueprint
from .auth import auth as auth_blueprint
app.register_blueprint(main_blueprint)
app.register_blueprint(auth_blueprint)
db.init_app(app)
login_manager.init_app(app)
return app
def create_app():
app = Flask(__name__)
CORS(app, supports_credentials=True)
app.debug = config.DEBUG
app.config['SECRET_KEY'] = config.SECRET_KEY
login_manager.init_app(app)
run_app(app, login_manager)
# will return none if doesnt match
return app
def register_extensions(app):
bootstrap.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
ckeditor.init_app(app)
moment.init_app(app)
toolbar.init_app(app)
migrate.init_app(app, db)
# print(cache.init_app)
cache.init_app(app)
whooshee.init_app(app)
dropzone.init_app(app)
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config_options[config_name])
from .main import main as main_blueprint
from .auth import auth as auth_blueprint
app.register_blueprint(main_blueprint)
app.register_blueprint(auth_blueprint, url_prefix='/authenticate')
bootstrap.init_app(app)
db.init_app(app)
mail.init_app(app)
login_manager.init_app(app)
configure_uploads(app, photos)
return app
def __extensions(app):
"""
Register 0 or more extensions (mutates the app passed in).
:param app: Flask application instance
:return: None
"""
debug_toolbar.init_app(app)
csrf.init_app(app)
db.init_app(app)
login_manager.init_app(app)
limiter.init_app(app)
return None
def create_app(config_type):
app = Flask(__name__)
configuration = os.path.join(os.getcwd(), 'config', config_type + '.py')
app.config.from_pyfile(configuration)
db.init_app(app)
# migrate.init_app(app, db)
bootstrap.init_app(app)
login_manager.init_app(app)
bcrypt.init_app(app)
from app.catalog import main
app.register_blueprint(main)
from app.auth import authentication
app.register_blueprint(authentication)
return app
def create_app(config_name):
app = Flask(__name__)
# Creating the app configurations
app.config.from_object(config_options[config_name])
#initialising blueprints
bootstrap.init_app(app)
db.init_app(app)
login_manager.init_app(app)
# Registering the blueprint
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/authenticate')
return app
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(Config)
db.init_app(app)
migrate.init_app(app)
bcrypt.init_app(app)
mail.init_app(app)
login_manager.init_app(app)
from market.users.routes import users
from market.posts.routes import posts
from market.main.routes import main
from market.errors.handlers import errors
app.register_blueprint(users)
app.register_blueprint(posts)
app.register_blueprint(main)
app.register_blueprint(errors)
return app
def create_app():
app = Flask(__name__)
app.config.from_object(Config)
admin.init_app(app)
db.init_app(app)
login_manager.init_app(app)
from myapp.main.routes import main
from myapp.scraper.routes import scraper
from myapp.user.routes import user
app.register_blueprint(main)
app.register_blueprint(scraper)
app.register_blueprint(user)
from myapp.admin import myadmin
app.register_blueprint(myadmin)
return app
def create_app(config_name):
app = Flask(__name__,
static_folder=os.path.abspath("build"),
static_url_path="/")
app.config.from_object(config[config_name])
db.init_app(app)
csrf.init_app(app)
login_manager.init_app(app)
from .main import main as main_blueprint
from .auth import auth as auth_blueprint
app.register_blueprint(main_blueprint, url_prefix="/api")
app.register_blueprint(auth_blueprint, url_prefix="/api")
@app.route("/")
def index():
return app.send_static_file("index.html")
return app
def create_app(config_name):
app = Flask(__name__, static_url_path='/static')
app.config.from_object(config_options[config_name])
db.init_app(app)
login_manager.init_app(app)
simple.init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
app.jinja_env.globals.update(countr=countr)
return app
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(Config)
pagedown.init_app(app)
markown.init_app(app)
db.init_app(app)
migrate.init_app(app, db)
bcrypt.init_app(app)
login_manager.init_app(app)
from app.contribution.routes import contribution
from app.factsheet.routes import factsheet
from app.main.routes import main
from app.users.routes import users
app.register_blueprint(contribution)
app.register_blueprint(factsheet)
app.register_blueprint(main)
app.register_blueprint(users)
return app
def register_extensions(app):
'''
扩展初始化
:param app:
:return:
'''
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
ckeditor.init_app(app)
moment.init_app(app)
toolbar.init_app(app)
migrate.init_app(app, db)
whooshee.init_app(app)
dropzone.init_app(app)
# 配置支付宝后才会启用支付接口对象
if app.config['ALIPAY']['ALIPAY_APP_ID']:
alipay.init_app(app)
# 配置微信支付后才会启用微信支付对象
if app.config['WXPAY']['APP_ID']:
wxpay.init_app(app)
def create_app():
app.config['SECRET_KEY'] = 'SOmE SeCRet KEy'
app.config['UPLOAD_FOLDER'] = 'uploads'
app.config['SQLALCHEMY_DATABASE_URI'] = f'sqlite:///{DB_NAME}'
db.init_app(app)
from .views import views
from .auth import auth
app.register_blueprint(views,url_prefix='/')
app.register_blueprint(auth, url_prefix='/')
from .models import User, DetImg
create_database(app)
login_manager = LoginManager()
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
@login_manager.user_loader
def load_user(id):
return User.query.get(int(id))
return app
from flask import Flask, request
from flask_login import current_user, login_manager, login_required, login_user, logout_user, UserMixin, LoginManager
flask_app = Flask(__name__)
flask_app.secret_key = 'aldfsidi'
login_manager = LoginManager()
login_manager.init_app(flask_app)
@login_manager.user_loader
def load_user(userid):
return UserObj(100, 'hhh')
class UserObj(UserMixin):
def __init__(self, _user_id, _user_name):
self.id = _user_id
self.user_name = _user_name
@flask_app.route('/login', methods=['GET'])
def login():
u_id = request.args['user_id']
u_name = request.args['user_name']
login_user(UserObj(u_id, u_name))
return "hello - {} - {}".format(u_id, u_name)
@flask_app.route('/logout', methods=['GET'])
def logout():
from wtforms.fields.core import StringField
from wtforms.validators import InputRequired, Email, Length, email_validator
from flask_login import LoginManager, UserMixin, login_manager, login_user, login_required, logout_user, current_user
from werkzeug.security import generate_password_hash, check_password_hash
subscribers = []
application = Flask(__name__)
api = Api(application)
CORS(application)
application.config['CORS_HEADERS'] = 'Content-Type'
application.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///fights.db'
application.config['SECRET_KEY'] = 'cairocoders-ednalan'
db = SQLAlchemy(application)
login_manager = LoginManager()
login_manager.init_app(application)
login_manager.login_view = 'login'
@login_manager.user_loader
def load_user(user_id):
return Fights.query.get(int(user_id))
class Fights(UserMixin, db.Model):
__tablename__ = 'fighters'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), nullable=False)
email = db.Column(db.String(200), unique=True, nullable=False)
def register_extensions(app):
print("registering extensions")
db.init_app(app)
login_manager.init_app(app)
from carpool import app
from carpool import models
from .forms import Ride, SearchRide
from carpool.rides.RideDto import RideDto
from carpool.rides.RideService import RideService
from carpool.auth.UserDto import UserDto
from carpool.auth.AuthService import AuthService, InvalidUserException
from carpool.notification.NotifyService import NotifyService
from carpool.booking.BookingService import BookingService
from carpool.booking.BookingDto import BookingDto
from random import randint
r = Blueprint('rides', __name__, url_prefix='/rides')
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'auth.signin'
@login_manager.user_loader
def load_user(email):
return models.Users.query.filter_by(email=email).first()
@app.before_request
def before_request():
g.user = current_user
@r.route('/registeride', methods=['GET', 'POST'])
@login_required
def on_load(state):
login_manager.init_app(state.app)
