def create_app(config_class="config.Config"):
from flask import Flask
app = Flask(__name__)
app.config.from_object(config_class)
jwt_utils.bind_jwt_messages(app)
api = Api(app)
api.add_resource(User, "/user/<string:username>")
api.add_resource(UserCreate, "/user")
api.add_resource(UserList, "/users")
api.add_resource(UserLogin, "/login")
api.add_resource(UserLogout, "/logout")
api.add_resource(UserChangePassword, "/change_password")
api.add_resource(MaintenanceActivity, "/activity/<int:id>")
api.add_resource(MaintenanceActivityCreate, "/activity")
api.add_resource(MaintenanceActivityList, "/activities")
api.add_resource(MaintainerWeeklyAvailabilityList,
"/maintainer/<int:activity_id>/availabilities")
api.add_resource(MaintainerDailyAvailability,
"/maintainer/<string:username>/availability")
api.add_resource(MaintenanceActivityAssign, "/activity/<int:id>/assign")
from db import db
db.init_app(app)
seeder = FlaskSeeder()
seeder.init_app(app, db)
return app
def setUp(self):
self.db_mock = MagicMock()
self.app = Flask("test")
self.cli = self.app.test_cli_runner()
self.seeder = FlaskSeeder()
self.seeder.init_app(self.app, db=self.db_mock)
def initialize_db(app):
app.app_context().push()
db.init_app(app)
db.create_all()
seeder = FlaskSeeder()
seeder.init_app(app, db)
def init_app():
"""Construct the core application."""
app = Flask(__name__)
db.init_app(app)
seeder = FlaskSeeder()
seeder.init_app(app, db)
return app
def create_app():
app = Flask(__name__)
db = SQLAlchemy()
db.init_app(app)
seeder = FlaskSeeder()
seeder.init_app(app, db)
return app
def test_init_app_without_db(self):
""" FlaskSeeder should use db object when passed via constructor.
"""
db = MagicMock()
app = MagicMock()
ext = {}
app.extensions.__setitem__.side_effect = ext.__setitem__
seeder = FlaskSeeder(db=db)
seeder.init_app(app)
self.assertEqual(ext["flask_seeder"].db, db)
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
db.init_app(app)
migrate.init_app(app, db)
login.init_app(app)
mail.init_app(app)
bootstrap.init_app(app)
moment.init_app(app)
babel.init_app(app)
seeder = FlaskSeeder()
seeder.init_app(app, db)
from app.errors import bp as errors_bp
app.register_blueprint(errors_bp)
from app.auth import bp as auth_bp
app.register_blueprint(auth_bp, url_prefix='/auth')
from app.main import bp as main_bp
app.register_blueprint(main_bp)
if not app.debug and not app.testing:
if app.config['MAIL_SERVER']:
auth = None
if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']:
auth = (app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD'])
secure = None
if app.config['MAIL_USE_TLS']:
secure = ()
mail_handler = SMTPHandler(
mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']),
fromaddr='no-reply@' + app.config['MAIL_SERVER'],
toaddrs=app.config['ADMINS'], subject='Microblog Failure',
credentials=auth, secure=secure)
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
if not os.path.exists('logs'):
os.mkdir('logs')
file_handler = RotatingFileHandler(
'logs/microblog.log', maxBytes=10240, backupCount=20)
file_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d'))
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.setLevel(logging.INFO)
app.logger.info('Microblog startup')
return app
def create_app():
"""Construct the core application."""
app = Flask(__name__, instance_relative_config=False)
app.config.from_object('config.Config')
db.init_app(app)
ma.init_app(app)
# Seed random data into tables.
seeder = FlaskSeeder()
seeder.init_app(app, db)
with app.app_context():
# Imports
from application.routes import errors, missions
# Reset tables.
db.drop_all()
db.create_all()
return app
def create_app(env=None):
from .db import db
from .ext import ma, migrate
from .config import config_by_name
from app.routes import register_routes
app = Flask(__name__)
app.config.from_object(config_by_name[env or "dev"])
api = Api(app, title="Credit Collection API", version="0.1.0")
register_routes(api, app)
db.init_app(app)
ma.init_app(app)
migrate.init_app(app, db)
seeder = FlaskSeeder()
seeder.init_app(app, db)
CORS(app)
return app
def development(app):
from flask_seeder import FlaskSeeder
FlaskSeeder(app, db)
application = Flask(__name__, template_folder=template_dir)
application.secret_key = os.environ.get('SECRET_KEY')
# Initiate database connection
connection_string = os.environ.get('DB_CONNECTION') + '://' + os.environ.get(
'DB_USERNAME') + '@' + os.environ.get(
'DB_PASSWORD') + '/' + os.environ.get('DATABASE_NAME')
application.config['SQLALCHEMY_DATABASE_URI'] = connection_string
application.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
application.config['SQLALCHEMY_ECHO'] = bool(os.environ.get('SQL_LOG'))
# register routes from urls
application.register_blueprint(routes)
csrf = CSRFProtect()
seeder = FlaskSeeder()
db.init_app(application)
seeder.init_app(application, db)
if __name__ == '__main__':
if os.environ.get('FLASK_ENV') == 'development':
application.debug = True
if os.environ.get('RECREATE_TABLES') == 'True':
recreateTables(application, db)
if os.environ.get('RECREATE_SEEDS') == 'True':
seedData(application, db)
application.run()
from flask_migrate import Migrate
from flask_seeder import FlaskSeeder
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy()
migrate = Migrate(compare_type=True)
flask_seeder = FlaskSeeder()
from limbook_api.db.base_model import BaseDbModel # noqa: E402
def setup_db(app):
""" Binds a flask application and a SQLAlchemy service"""
db.app = app
db.init_app(app)
# setup migration
migrate.init_app(app, db)
# setup flask seed
flask_seeder.init_app(app, db)
def db_drop_and_create_all():
"""Drops the database tables and start fresh"""
db.drop_all()
db.create_all()
#Memanggil library Flask from flask import Flask from config import Config from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate from flask_seeder import FlaskSeeder #Inisialisasi JWT from flask_jwt_extended import JWTManager #Untuk menjelaskan nama modul yang digunakan, sehingga ketika folder lain memanggil folder app akan otomatis teridentifikasi. app = Flask(__name__) app.config.from_object(Config) db = SQLAlchemy(app) migrate = Migrate(app, db) jwt = JWTManager(app) seeder = FlaskSeeder() seeder.init_app(app, db) #Memanggil file routes from app.model import todo, user from app import routes
class TestSeedCLI(TestCase):
def setUp(self):
self.db_mock = MagicMock()
self.app = Flask("test")
self.cli = self.app.test_cli_runner()
self.seeder = FlaskSeeder()
self.seeder.init_app(self.app, db=self.db_mock)
@patch("flask_seeder.cli.os.walk", return_value=MOCK_FILES)
def test_get_seed_scripts_return_list_of_modules(self, mocked):
expected_result = [
os.path.join("data", "sub1", "file1.py"),
os.path.join("data", "sub1", "file2.py"),
os.path.join("data", "sub2", "file3.py"),
os.path.join("data", "sub2", "file4.py"),
]
modules = cli.get_seed_scripts()
self.assertListEqual(modules, expected_result)
@patch("flask_seeder.cli.get_seeders")
def test_seeder_calls_run_method_on_loaded_modules(self, m_get_seeders):
m_seeder = MagicMock()
m_get_seeders.return_value = [m_seeder]
self.cli.invoke(cli.seed_run)
m_seeder.run.assert_called_once()
@patch("flask_seeder.cli.get_seed_scripts", return_value=["test"])
@patch("flask_seeder.cli.get_seeders_from_script")
def test_get_seeders_return_ordered_iterable_of_seeders(
self, m_get_seeders, m_get_scripts):
class TestSeeder:
def __init__(self, priority=None):
if priority:
self.priority = priority
class QQTestSeeder:
def __init__(self, priority=None):
if priority:
self.priority = priority
unordered_seeder_list = [
TestSeeder(10),
QQTestSeeder(),
TestSeeder(),
QQTestSeeder(1)
]
m_get_seeders.return_value = unordered_seeder_list
expected_result = [
unordered_seeder_list[3], unordered_seeder_list[0],
unordered_seeder_list[1], unordered_seeder_list[2]
]
result = list(cli.get_seeders())
self.assertListEqual(result, expected_result)
@patch("flask_seeder.cli.get_seeders")
def test_seed_list_print_list_of_seeders(self, m_get_seeders):
m_seeder = MagicMock()
m_seeder.name = "testseeder"
m_get_seeders.return_value = [m_seeder]
result = self.cli.invoke(cli.seed_list)
self.assertTrue("testseeder" in result.output)
@patch("flask_seeder.cli.get_seeders")
def test_seed_run_echo_failed_runs(self, m_get_seeders):
class TestSeeder(Seeder):
def run(self):
raise ValueError()
m_get_seeders.return_value = [TestSeeder()]
result = self.cli.invoke(cli.seed_run)
self.assertTrue("ERROR" in result.output)
@patch("flask_seeder.cli.get_seeders")
def test_root_option_with_list(self, m_get_seeders):
self.cli.invoke(cli.seed_list, args=["--root", "sub1"])
m_get_seeders.assert_called_once_with(root="sub1")
@patch("flask_seeder.cli.get_seeders")
def test_root_option_with_run(self, m_get_seeders):
self.cli.invoke(cli.seed_run, args=["--root", "sub1"])
m_get_seeders.assert_called_once_with(root="sub1")
@patch("flask_seeder.cli.get_seeders")
def test_run_with_seeder_argument(self, m_get_seeders):
m_seeder = MagicMock()
m_seeder.name = "TestSeeder"
m_get_seeders.return_value = [m_seeder]
self.cli.invoke(cli.seed_run, args=["TestSeeder"])
m_seeder.run.assert_called_once()
@patch("flask_seeder.cli.get_seeders", return_value=[])
def test_run_commit_session_by_default(self, m_get_seeders):
self.cli.invoke(cli.seed_run)
self.db_mock.session.commit.assert_called()
@patch("flask_seeder.cli.get_seeders", return_value=[])
def test_run_avoid_commit_with_no_commit_option(self, m_get_seeders):
self.cli.invoke(cli.seed_run, args=["--no-commit"])
self.assertFalse(self.db_mock.session.commit.called)
def setup_database_seeder(_app, _db):
seeder = FlaskSeeder()
seeder.init_app(_app, _db)
# Imports
from flask import Flask
from flask_cors import CORS
from flask_sqlalchemy import SQLAlchemy
from flask_seeder import FlaskSeeder
# Database
db = SQLAlchemy()
seeder = FlaskSeeder()
from CustomApi.models import *
def create_app():
# instantiate the app
app = Flask(__name__)
#static_url_path='/static', static_folder='/static'
app.config.from_object('CustomApi.config.BaseConfig')
db.init_app(app)
seeder.init_app(app, db)
# enable CORS for unrestrected js request
from CustomApi.main.routes import main
from CustomApi.products.routes import api as products
from CustomApi.users.routes import api as users
from CustomApi.cart.routes import api as cart
from CustomApi.login.routes import api as login
from CustomApi.otp.routes import api as otp
from CustomApi.signup.routes import api as signup
def init_db(app):
db.init_app(app)
Migrate(app, db)
seeder = FlaskSeeder()
seeder.init_app(app, db)
app.config.from_object("src.config.Config")
# cache
# cache = Cache(app, config=app.config['REDIS_CONFIG'])
cache = None
# cors
CORS(app)
# db
db = SQLAlchemy(app)
# migrate
migrate = Migrate(app, db, compare_type=True)
# ma
ma = Marshmallow()
# routes
api = Api(app)
# seeder
seeder = FlaskSeeder(app, db)
# logging
import logging.config
logging.config.dictConfig(app.config['LOGGING_CONFIG'])
# import models
from .models import *
# import routes
from .routes import *
# import services
from .services import *
# import common
from .common import (
def create_app(env_name):
"""
Create app
"""
# app initiliazation
app = Flask(__name__)
# cors
CORS(app, supports_credentials=True)
# cors = CORS(app)
# cors = CORS(app, resources={r"/api/*": {"origins": "http://*****:*****@app.route('/')
def index():
"""
example endpoint
"""
app.logger.info('Mostrando los posts del blog')
return 'TAT 5005'
# @app.after_request
# def after_request(response):
# # response.headers.add('Access-Control-Allow-Origin', '*')
# # response.headers.add('Access-Control-Allow-Headers', 'Content-Type')
# response.headers.add('Access-Control-Allow-Origin', 'http://localhost:8080')
# response.headers.add('Access-Control-Allow-Headers', 'Content-Type,Authorization')
# response.headers.add('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS')
# response.headers.add('Access-Control-Allow-Credentials', 'true')
# print("123123123213213333333333333333333333333333333333333")
# return response
return app
