def init_app(config_file, name=None, **kwargs) -> Flask:
name = name or __name__
app = Flask(name, static_url_path='', **kwargs)
app.srv_config = create_from_config_file(Configuration,
entity_conf=[{
"class":
FedEntityConfiguration,
"attr":
"federation",
"path": ["federation"]
}],
filename=config_file,
base_path=dir_path)
# app.users = {'test_user': {'name': 'Testing Name'}}
try:
from .views import intermediate
except ImportError:
from views import intermediate
app.register_blueprint(intermediate)
# Initialize the oidc_provider after views to be able to set correct urls
app.server = init_entity(app.srv_config.federation, dir_path)
return app
def oidc_provider_init_app(config_file, name=None, **kwargs):
name = name or __name__
app = Flask(name, static_url_path='', **kwargs)
app.srv_config = create_from_config_file(Configuration,
entity_conf=[{
"class": FedRPConfiguration,
"attr": "rp"
}],
filename=config_file,
base_path=dir_path)
app.users = {'test_user': {'name': 'Testing Name'}}
try:
from .views import oidc_rp_views
except ImportError:
from views import oidc_rp_views
app.register_blueprint(oidc_rp_views)
# Initialize the oidc_provider after views to be able to set correct urls
app.rph = init_oidc_rp_handler(app.srv_config.rp, dir_path)
return app
def create_app(spark_context, app):
global recommendationengine
recommendationengine = RecommendationEngine(spark_context, app)
app = Flask(__name__)
app.register_blueprint(main)
return app
def create_app(config: dict = {}, mail_client=None):
app = Flask(__name__, static_folder='static')
if config:
app.config.update(config)
else:
app.config.from_envvar('ALSERVICE_CONFIG')
MakoTemplates(app)
app._mako_lookup = TemplateLookup(directories=[pkg_resources.resource_filename('alservice.service', 'templates')],
input_encoding='utf-8', output_encoding='utf-8',
imports=['from flask_babel import gettext as _'])
app.al = init_account_linking(app, mail_client)
babel = Babel(app)
babel.localeselector(get_locale)
app.config['BABEL_TRANSLATION_DIRECTORIES'] = pkg_resources.resource_filename('alservice.service',
'data/i18n/locales')
from .views import account_linking_views
app.register_blueprint(account_linking_views)
setup_logging(app.config.get('LOGGING_LEVEL', 'INFO'))
logger = logging.getLogger(__name__)
logger.info('Running ALservice version %s', pkg_resources.get_distribution('ALservice').version)
return app
def init_app(app: Flask):
from . import auth, user, order, shop, admin, merchant
app.register_blueprint(auth.app)
app.register_blueprint(user.app)
app.register_blueprint(order.app)
app.register_blueprint(shop.app)
app.register_blueprint(admin.app)
app.register_blueprint(merchant.app)
def create_app(config_filename=None):
app = Flask(__name__)
app.config.from_object(hepdata_converter_ws)
from hepdata_converter_ws.api import api
app.register_blueprint(api)
return app
def create_app():
app = Flask(__name__)
from . import api
app.register_blueprint(api.bp)
app.height = int(os.environ.get('PREDICTOR_HEIGHT', '0'))
app.feature_type = os.environ.get('PREDICTOR_FEATURE_TYPE')
app.logger.debug(f"Building predictor: {app.feature_type}")
return app
def create_app(config_filename=None):
app = Flask(__name__)
app.config.from_object(hepdata_converter_ws)
from hepdata_converter_ws.api import api
app.register_blueprint(api)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
bootstrap.init_app(app)
db.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
return app
def create_app():
app = Flask(__name__)
from . import api
app.register_blueprint(api.bp)
app.identifier = os.environ.get('VECTORIZER_IDENTIFIER')
app.width = int(os.environ.get('VECTORIZER_WIDTH', '0'))
app.constructor = os.environ.get('VECTORIZER_CONSTRUCTOR')
app.logger.debug(f"Building vectorizer: {app.constructor}")
return app
def create_app(self):
from openbrokerapi.api import get_blueprint
app = Flask(__name__)
self.broker = Mock()
app.register_blueprint(
get_blueprint(self.broker, BrokerCredentials("", ""),
basic_config(level=logging.WARN)))
return app
def create_app():
app = Flask(__name__)
bootstrap = Bootstrap(app)
app.config.from_object(Config)
# login manager inicializando la app
login_manager.init_app(app)
# Se registra el nuevo blueprint auth
app.register_blueprint(auth)
return app
def init_app(name=None):
name = name or __name__
app = Flask(name)
app.config.from_pyfile('application.cfg')
app.config.from_pyfile('production.cfg')
app.jinja_env.globals['GIT_HASH'] = get_git_hash()
#app.ldap_orm = Connection(app.config['LDAP_URL'], app.config['LDAP_BIND_DN'], app.config['LDAP_BIND_PW'], auto_bind=True)
server = Server(app.config['LDAP_URL'], get_info=ALL)
app.ldap_conn = Connection(server,
app.config['LDAP_BIND_DN'],
app.config['LDAP_BIND_PW'],
auto_bind=True)
model.ldap_conn = app.ldap_conn
model.base_dn = app.config['LDAP_BASE_DN']
from .model import db
db.init_app(app)
with app.app_context():
db.create_all()
app.babel = Babel(app)
init_oauth2(app)
app.login_manager = LoginManager(app)
#init hydra admin api
hydra_config = hydra.Configuration(
host=app.config['HYDRA_ADMIN_URL'],
username=app.config['HYDRA_ADMIN_USER'],
password=app.config['HYDRA_ADMIN_PASSWORD'])
hydra_client = hydra.ApiClient(hydra_config)
app.hydra_api = hydra.AdminApi(hydra_client)
from .views import auth_views, frontend_views, init_login_manager, api_views, pki_views, admin_views
init_login_manager(app)
app.register_blueprint(auth_views)
app.register_blueprint(frontend_views)
app.register_blueprint(api_views)
app.register_blueprint(pki_views)
app.register_blueprint(admin_views)
@app.before_request
def befor_request():
request_start_time = time.time()
g.request_time = lambda: "%.5fs" % (time.time() - request_start_time)
from .translations import init_babel
init_babel(app)
app.lenticular_services = {}
for service_name, service_config in app.config[
'LENTICULAR_CLOUD_SERVICES'].items():
app.lenticular_services[service_name] = model.Service.from_config(
service_name, service_config)
app.pki = Pki(app.config['PKI_PATH'], app.config['DOMAIN'])
return app
def oidc_provider_init_app(name=None):
name = name or __name__
app = Flask(name)
app.config.from_pyfile('application.cfg')
app.users = {'test_user': {'name': 'Testing Name'}}
from .views import oidc_provider_views
app.register_blueprint(oidc_provider_views)
# Initialize the oidc_provider after views to be able to set correct urls
app.provider = init_oidc_provider(app)
return app
def oidc_provider_init_app(name=None):
name = name or __name__
app = Flask(name)
app.config.from_pyfile("application.cfg")
app.users = {"test_user": {"name": "Testing Name"}}
from .views import oidc_blueprint
app.register_blueprint(oidc_blueprint)
# Initialize the oidc_provider after views to be able to set correct urls
app.provider = init_oidc_provider(app)
return app
def oidc_provider_init_app(op_config, name=None, **kwargs):
name = name or __name__
app = Flask(name, static_url_path='', **kwargs)
app.srv_config = op_config
try:
from .views import oidc_op_views
except ImportError:
from views import oidc_op_views
app.register_blueprint(oidc_op_views)
# Initialize the oidc_provider after views to be able to set correct urls
app.server = init_oidc_op(app)
return app
def create_app(config_name):
# Creating instance
app = Flask(__name__)
# Creating the app conifgurations
app.config.from_object(config_options[config_name])
#Registering the blueprint
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
#Setting config
from .requests import configure_requests
configure_requests(app)
return app
def register_routes(_app: Flask):
"""Registers api resources/routes with Flask app
Args:
_app (object): Flask app object
"""
api_blueprint = Blueprint("api", __name__)
api = Api(api_blueprint, catch_all_404s=False)
api.add_resource(
resources.CoursesList, "/courses")
api.add_resource(
resources.CoursesDetailed, "/courses/<int:id>")
_app.register_blueprint(api_blueprint, url_prefix="/api")
def oidc_provider_init_app(name=None):
name = name or __name__
app = Flask(name)
app.config.from_pyfile('application.cfg')
from views import oidc_provider_views
app.register_blueprint(oidc_provider_views)
# Initialize the oidc_provider after views to be able to set correct urls
app.provider = init_oidc_provider(app)
sess = Session()
sess.init_app(app)
login_manager = LoginManager()
login_manager.init_app(app)
return app
def register_blueprints(*, server: Flask) -> None:
"""Register all blueprints located in /routes modules to the flask app
Args:
server: flask server object to hook blueprints to.
Returns:
None
"""
for name in find_modules("btc_dash.routes"):
# it doesnt like to import robots from btc_dash.routes.robots
# so hack around the import string.
name = name.split(".")
name = ".".join(name + [name[-1]])
module = import_string(name)
server.register_blueprint(module)
def app_factory(config):
'''This factory creates a Flask application instance based on the settings
in the provided configuration object.'''
# Create the Flask app, register the blueprint and initialize the
# flask-mail service.
# Blueprints must be used to implement factories (I believe) because
# they allow the factory to register the application's routes
# before they must be implemented.
app = Flask(__name__)
app.config.from_object(config)
from app.views import web
app.register_blueprint(web)
mail.init_app(app)
# Create the (only) mongodb instance for use by all running applications.
# Different apps may use different Mongo databases.
# The production server already has its data, so don't always
# call db_reset().
mongo = PyMongo(app)
if config.DATA:
with app.app_context():
db_reset(mongo, config.DATA)
# Store the Mongo database object in the Flask globals so that it can
# be accessed when needed.
@app.before_request
def before_request():
g.mongo = mongo
# This Jinja2 template must be defined here, on the app, rather than
# in views.py on the blueprint.
@app.template_filter('start_token')
def start_token(name):
'''This routine returns the substring of the given name up to but not
including the first slash. If there is no slash, it returns the
full name. It is used in the templates to find either the page
name or category.'''
if (name.find('/') == -1):
return name
else:
return name[:name.find('/')]
return app
def register_blueprints(*, app: Flask) -> None:
"""Register all blueprints located in /routes modules to the flask app
Args:
app (Flask): flask server object to hook blueprints to.
"""
for name in find_modules("app.routes"):
name = name.split(".")
name = ".".join(name + ['blueprint'])
try:
module = import_string(name)
except:
continue
if isinstance(module, flask.blueprints.Blueprint):
app.logger.info(f"Registering {name}...")
app.register_blueprint(module)
def make_app(import_name=__name__,
config='homebank.settings.Configuration',
debug=False):
app = Flask(import_name)
app.config.from_object(config)
app.config.from_envvar('FLASK_SETTINGS', silent=True)
app.debug = debug
app.jinja_env.filters['currency'] = \
lambda x: "{:,.2f} %s".format(x).replace(",", " ").replace(".", ",") % (
app.config.get('CURRENCY', '')
)
if app.debug:
import_string('flask.ext.debugtoolbar:DebugToolbarExtension')(app)
@app.errorhandler(404)
def not_found(ex):
return render_template("404.html"), 404
for blueprint in ['__init__', 'accounts', 'transactions']:
app.register_blueprint(
import_string('homebank.blueprints.%s:root' % blueprint))
login_manager = LoginManager(app=app)
login_manager.login_view = "index.login"
login_manager.session_protection = "strong"
@login_manager.user_loader
def load_user(uid):
if uid != app.config['PINCODE']:
return None
return User()
if not app.debug:
handler = StreamHandler()
if 'ERROR_LOG' in app.config:
handler = WatchedFileHandler(app.config['ERROR_LOG'])
handler.setLevel(WARNING)
handler.setFormatter(
Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
app.logger.addHandler(handler)
return app
def create_app():
app = Flask(__name__)
app.config.from_object(os.environ.get('DISPATCHER_CONFIG_CLASS'))
from . import api
app.register_blueprint(api.bp)
from .database import db
db.init_app(app)
app.vectorizers = [
requests.get(vectorizer).json()
for vectorizer in json.loads(os.environ.get('DISPATCHER_VECTORIZERS'))
]
app.predictors = [
requests.get(predictor).json()
for predictor in json.loads(os.environ.get('DISPATCHER_PREDICTORS'))
]
app.models = json.loads(os.environ.get('DISPATCHER_MODELS'))
app.logger.debug(f"Building dispatcher: {app.models}")
return app
def oidc_provider_init_app(name=None, **kwargs):
name = name or __name__
app = Flask(name, static_url_path='', **kwargs)
app.config.from_pyfile(os.path.join(folder,'conf.py'))
#app.users = {'test_user': {'name': 'Testing Name'}}
try:
from .views import oidc_op_views
except ImportError:
from views import oidc_op_views
app.register_blueprint(oidc_op_views)
# Initialize the oidc_provider after views to be able to set correct urls
app.endpoint_context = init_oidc_op_endpoints(app)
return app
def oidc_provider_init_app(config_file, name=None, **kwargs):
name = name or __name__
app = Flask(name, static_url_path='', **kwargs)
app.config.from_pyfile(os.path.join(dir_path, config_file))
app.users = {'test_user': {'name': 'Testing Name'}}
try:
from .views import oidc_rp_views
except ImportError:
from views import oidc_rp_views
app.register_blueprint(oidc_rp_views)
# Initialize the oidc_provider after views to be able to set correct urls
app.rph = init_oidc_rp_handler(app)
return app
def create_app(test_config=None):
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping(
SECRET_KEY='dev',
# 数据库的路径和名称
DATABASE=os.path.join(app.instance_path, 'flaskr.sqlite'),
)
if test_config is None:
# load the instance config, if it exists, when not testing
app.config.from_pyfile('config.py', silent=True)
else:
# load the test config if passed in
app.config.from_mapping(test_config)
# ensure the instance folder exists
try:
os.makedirs(app.instance_path)
except OSError:
pass
# 从 views.py 中调用 init_route() 函数，称为懒加载
# init_route(app)
# 导入auth.py 的bp的 蓝图 函数
from . import auth
app.register_blueprint(auth.bp)
# 导入系统 system.py 的 bp蓝图
from . import system
app.register_blueprint(system.bp)
app.add_url_rule('/', endpoint='index')
# 用户端蓝图
init_user(app=app)
# 管理员端蓝图
init_admin(app=app)
# 导入数据库文件 db.py
from . import db
db.init_app(app)
return app
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(Config)
with app.app_context():
db.init_app(app)
login_manager.init_app(app)
sess.init_app(app)
from . import models
from .routes import main
app.register_blueprint(main)
# from app.users.routes import users
# from app.quiz.routes import quiz
# from app.home.routes import home
# app.register_blueprint(users)
# app.register_blueprint(quiz)
# app.register_blueprint(home)
return app
class EmailActivationTest(TestCase):
def setUp(self):
self.app = Flask(__name__)
self.app.register_blueprint(emailactivation.views.app)
self.app.config['SECRET_KEY'] = 'SECRET'
self.mail = Mail(self.app)
@self.app.route('/index')
def index():
return 'index'
def testSendEmail(self):
callback = my_callback
data = {'mail':'*****@*****.**'}
email = {'subject':'subject',
'sender':'*****@*****.**'}
with patch('test_activation.my_callback') as c:
with self.app.test_request_context():
c.return_value = url_for('index')
signature = signature_serialize(callback, data)
with self.mail.record_messages() as outbox:
send_activation_email(self.mail,
'*****@*****.**',
callback=callback,
data=data,
email_context=email,
template_context={},
body_template='test.html')
self.assertEquals(1, len(outbox), 'Email was sent')
self.assertIn(url_for('emailactivation.activation',
signature=signature, _external=True),
outbox[0].body)
with self.app.test_client() as client:
response = client.get(url_for('emailactivation.activation',
signature=signature,))
self.assertEquals(302, response.status_code)
self.assertEquals(url_for('index', _external=True),
response.location)
def __new__(cls, *args, **kwargs):
if cls._instance is None:
app = Flask(__name__)
app.register_blueprint(PeopleBluePrintFactory.create())
flask_injector = FlaskInjector(
app=app,
modules=[DatabaseModule(), ],
)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/production.db'
db.init_app(app)
with app.app_context():
db.create_all()
cls._instance = flask_injector
return cls._instance
def create_app(config_name):
app = Flask(__name__)
print(__name__)
app.config.from_object(config[config_name])
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
# 初始化db
db.init_app(app)
login_manager.init_app(app)
# 初始化日志配置
common = LogCommon()
app = common.init_log(app, 'log')
# 附加路由和自定义的错误页面
from app.pyweb.main import main
app.register_blueprint(main)
# 定义认证路由
from app.pyweb.auth import auth
app.register_blueprint(auth, url_prefix='/auth')
# 定义Captcha路由
from app.pyweb.captcha_chinese import captcha
app.register_blueprint(captcha, url_prefix='/captcha')
return app
def make_app(import_name=__name__, config="homebank.settings.Configuration", debug=False):
app = Flask(import_name)
app.config.from_object(config)
app.config.from_envvar("FLASK_SETTINGS", silent=True)
app.debug = debug
app.jinja_env.filters["currency"] = lambda x: "{:,.2f} %s".format(x).replace(",", " ").replace(".", ",") % (
app.config.get("CURRENCY", "")
)
if app.debug:
import_string("flask.ext.debugtoolbar:DebugToolbarExtension")(app)
@app.errorhandler(404)
def not_found(ex):
return render_template("404.html"), 404
for blueprint in ["__init__", "accounts", "transactions"]:
app.register_blueprint(import_string("homebank.blueprints.%s:root" % blueprint))
login_manager = LoginManager(app=app)
login_manager.login_view = "index.login"
login_manager.session_protection = "strong"
@login_manager.user_loader
def load_user(uid):
if uid != app.config["PINCODE"]:
return None
return User()
if not app.debug:
handler = StreamHandler()
if "ERROR_LOG" in app.config:
handler = WatchedFileHandler(app.config["ERROR_LOG"])
handler.setLevel(WARNING)
handler.setFormatter(Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
app.logger.addHandler(handler)
return app
def oidc_provider_init_app(config_file, name=None, **kwargs):
name = name or __name__
app = Flask(name, static_url_path='', **kwargs)
app.rp_config = Configuration.create_from_config_file(config_file)
# Session key for the application session
app.config['SECRET_KEY'] = os.urandom(12).hex()
app.users = {'test_user': {'name': 'Testing Name'}}
try:
from .views import oidc_rp_views
except ImportError:
from views import oidc_rp_views
app.register_blueprint(oidc_rp_views)
# Initialize the oidc_provider after views to be able to set correct urls
app.rph = init_oidc_rp_handler(app)
return app
def oidc_provider_init_app(name=None, config=None):
name = name or __name__
app = Flask(name)
app.config.from_envvar(SE_LEG_PROVIDER_SETTINGS_ENVVAR)
if config:
app.config.update(config)
# Init logging
app = init_logging(app)
# Init middleware
app.wsgi_app = LocalhostMiddleware(app.wsgi_app, server_name=app.config['SERVER_NAME'])
# Initialize registry for plugin handling
r = Registry(app=app)
r['packages'] = PackageRegistry(app)
r['extensions'] = ExtensionRegistry(app)
r['config'] = ConfigurationRegistry(app)
r['blueprints'] = BlueprintAutoDiscoveryRegistry(app=app)
# Init dbs
app.authn_requests = OpStorageWrapper(app.config['DB_URI'], 'authn_requests')
app.users = OpStorageWrapper(app.config['DB_URI'], 'userinfo')
# Init queues
app = init_redis_connection(app)
app.authn_response_queue = rq.Queue('authn_responses', connection=app.redis)
app.authn_response_delay_queue = Scheduler(queue_name='authn_responses', connection=app.redis)
# Set up views
from .views.oidc_provider import oidc_provider_views
app.register_blueprint(oidc_provider_views)
from .views.status import status_views
app.register_blueprint(status_views)
# Initialize the oidc_provider after views to be able to set correct urls
app.provider = init_oidc_provider(app)
return app
def register_blueprints(*, server: Flask) -> None:
"""Register all blueprints located in /routes modules to the flask app
Args:
server: flask server object to hook blueprints to.
Returns:
None
"""
for name in find_modules("btc_dash.routes"):
# it doesnt like to import robots from btc_dash.routes.robots
# so hack around the import string.
name = name.split(".")
name = ".".join(name + [name[-1]])
try:
module = import_string(name)
except: # noqa: E722
server.logger.info(f"{name} not a blueprint, skipping...")
continue
if isinstance(module, flask.blueprints.Blueprint):
server.logger.info(f"Registering {name}...")
server.register_blueprint(module)
def oidc_provider_init_app(config_file, name=None, **kwargs):
name = name or __name__
app = Flask(name, static_url_path='', **kwargs)
if config_file.endswith('.yaml'):
app.config.update(load_yaml_config(config_file))
elif config_file.endswith('.py'):
app.config.from_pyfile(os.path.join(dir_path, config_file))
else:
raise ValueError('Unknown configuration format')
app.users = {'test_user': {'name': 'Testing Name'}}
try:
from .views import oidc_rp_views
except ImportError:
from views import oidc_rp_views
app.register_blueprint(oidc_rp_views)
# Initialize the oidc_provider after views to be able to set correct urls
app.rph = init_oidc_rp_handler(app)
return app
def create_app():
application = Flask(__name__)
application.secret_key = gen_random_password()
Bootstrap(application)
application.register_blueprint(base_bp)
application.register_blueprint(files_bp)
application.register_blueprint(helpers_bp)
return application
class SimpleFlaskAppTest(unittest.TestCase):
def setUp(self):
self.app = Flask(__name__)
self.client = self.app.test_client()
self.db = MongoEngine(self.app)
with self.app.app_context():
self.db.connection.drop_database("test")
# self.db.connection
class TestCol(db.Document):
value = db.StringField()
def __unicode__(self):
return "TestCol(value={})".format(self.value)
TestCol.objects.delete()
TestCol.objects.create(value="1")
TestCol.objects.create(value="2")
self.TestCol = TestCol
def _parse(self, resp):
resp = resp.decode("utf-8")
return json.loads(resp)
def test_validation_mongoengine_will_work_with_model_serializer(self):
class Doc(db.Document):
value = db.StringField(validation=RegexpValidator(r"\d+", message="Bad value").for_mongoengine())
Doc.drop_collection()
class Serializer(ModelSerializer):
class Meta:
model = Doc
Doc.objects.create(value="123")
s = Serializer(data={"value": "asd"})
self.assertEqual(s.validate(), False)
self.assertEqual(s.errors, {"value": ["Bad value"]})
def test_resource_decorator(self):
class S(BaseSerializer):
field = fields.StringField(required=True)
@self.app.route("/test", methods=["POST"])
@validate(S)
def resource(cleaned_data):
return "OK"
resp = self.client.post("/test", data=json.dumps({}), headers={"Content-Type": "application/json"})
self.assertEqual(resp.status_code, 400)
self.assertEqual(
json.loads(resp.data.decode("utf-8")), {'field': ['Field is required']}
)
def testSimpleResourceAndRouter(self):
router = DefaultRouter(self.app)
class Resource(BaseResource):
def get(self, request):
return "GET"
def post(self, request):
return "POST"
def put(self, request):
return "PUT"
def patch(self, request):
return "PATCH"
def delete(self, request):
return "DELETE"
@list_route(methods=["GET", "POST"])
def listroute(self, request):
return "LIST"
@detail_route(methods=["GET", "POST"])
def detailroute(self, request, pk):
return "detail"
self.assertSetEqual(
set(Resource.get_allowed_methods()), {"get", "post", "put", "patch", "delete"}
)
router.register("/test", Resource, "test")
for method in ["get", "post", "put", "patch", "delete"]:
resp = getattr(self.client, method)("/test")
self.assertEqual(resp.data.decode("utf-8"), method.upper())
for method in ["GET", "POST"]:
resp = getattr(self.client, method.lower())("/test/listroute")
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.data.decode("utf-8"), "LIST")
for method in ["GET", "POST"]:
resp = getattr(self.client, method.lower())("/test/detailroute/1")
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.data.decode("utf-8"), "detail")
resp = self.client.get("/test/detailroute")
self.assertEqual(resp.status_code, 404)
def testRoutingWithBluePrint(self):
bp = Blueprint("test", __name__)
router = DefaultRouter(bp)
class Res(BaseResource):
def get(self, request):
return "GET"
router.register("/blabla", Res, "blabla")
self.app.register_blueprint(bp, url_prefix="/test")
with self.app.test_request_context():
self.assertEqual(url_for("test.blabla"), "/test/blabla")
@pytest.mark.testModelResource123
def testModelResource(self):
router = DefaultRouter(self.app)
class Base(db.Document):
title = db.StringField()
class ED(db.EmbeddedDocument):
value = db.StringField()
class Model(db.Document):
base = db.ReferenceField(Base)
f1 = db.StringField()
f2 = db.BooleanField()
f3 = db.StringField()
embedded = db.EmbeddedDocumentField(ED)
listf = db.EmbeddedDocumentListField(ED)
dictf = db.DictField()
Model.objects.delete()
ins = Model.objects.create(
base=Base.objects.create(title="1"),
f1="1",
f2=True,
f3="1",
embedded={"value": "123"},
listf=[{"value": "234"}],
dictf={"key": "value"}
)
Model.objects.create(
base=Base.objects.create(title="2"),
f1="2",
f2=True,
f3="2",
embedded={"value": "123"},
listf=[{"value": "234"}]
)
class S(ModelSerializer):
title = fields.ForeignKeyField("base__title")
class Meta:
model = Model
fk_fields = ("base__title", )
class ModelRes(ModelResource):
serializer_class = S
queryset = Model.objects.all()
pagination_class = DefaultPagination
router.register("/test", ModelRes, "modelres")
resp = self.client.get("/test")
self.assertEqual(resp.status_code, 200)
data = self._parse(resp.data)
self.assertEqual(len(data["results"]), 2)
item = data["results"][0]
self.assertEqual(item["dictf"], {"key": "value"})
self.assertEqual(item["title"], "1")
self.assertEqual(item["base__title"], "1")
# get one object
resp = self.client.get("/test/{}".format(ins.id))
self.assertEqual(resp.status_code, 200)
pprint(self._parse(resp.data))
#test pagination
for i in range(10):
Model.objects.create(
base=Base.objects.create(title="1"),
f1="1",
f2=True,
f3="2"
)
self.assertEqual(Model.objects.count(), 12)
resp = self.client.get("/test?page=1")
self.assertEqual(resp.status_code, 200)
data = self._parse(resp.data)
results = data["results"]
self.assertEqual(results[0]["embedded"], {"value": "123"})
self.assertEqual(results[0]["listf"], [{"value": "234"}])
self.assertEqual(len(data["results"]), 10)
resp = self.client.get("/test?page=2")
self.assertEqual(resp.status_code, 200)
data = self._parse(resp.data)
self.assertEqual(len(data["results"]), 2)
resp = self.client.get("/test?page=2&page_size=5")
self.assertEqual(resp.status_code, 200)
data = self._parse(resp.data)
self.assertEqual(len(data["results"]), 5)
resp = self.client.get("/test?page=3&page_size=5")
self.assertEqual(resp.status_code, 200)
data = self._parse(resp.data)
self.assertEqual(len(data["results"]), 2)
#test put
resp = self.client.put("/test/{}".format(ins.id), data=json.dumps({
"f3": "OLALA"
}), headers={"Content-Type": "application/json"})
self.assertEqual(resp.status_code, 200, resp.data)
data = self._parse(resp.data)
self.assertEqual(data["f1"], "1")
self.assertEqual(data["f2"], True)
self.assertEqual(data["f3"], "OLALA")
def testMongoEngineForeignKeyField(self):
self.assertEqual(self.TestCol.objects.count(), 2)
class Serializer(BaseSerializer):
fk = fields.MongoEngineIdField(self.TestCol, required=True)
v = Serializer({"fk": "123"})
self.assertEqual(v.validate(), False)
self.assertEqual(v.errors, {'fk': ['Incorrect id: 123']})
v = Serializer({"fk": str(self.TestCol.objects.first().id)})
v.validate()
self.assertEqual(v.errors, {})
self.assertEqual(v.cleaned_data["fk"], self.TestCol.objects.first())
class R(BaseResource):
def post(self, request):
errors, data = self.validate_request(Serializer)
if errors:
return errors
return "OK"
self.app.add_url_rule("/api", view_func=R.as_view("test2"),
methods=["GET", "POST"])
resp = self.client.post("/api", data=json.dumps({}),
headers={"Content-Type": "application/json"})
self.assertEqual(resp.status_code, 400)
data = json.loads(resp.data.decode("utf-8"))
self.assertEqual(data["fk"], ['Field is required'])
def testSerialization(self):
class Col(db.Document):
value = db.StringField()
created = db.DateTimeField(default=datetime.datetime.now)
Col.objects.delete()
Col.objects.create(value="1")
Col.objects.create(value="2")
class S(BaseSerializer):
value = fields.StringField()
created = fields.DateTimeField(read_only=True)
data = S(Col.objects.all()).to_python()
self.assertEqual(len(data), 2)
self.assertEqual(
list(map(lambda i: i["value"], data)),
["1", "2"]
)
#test can't set read only field
ser = S({"value": "1", "created": "2016-01-01 00:00:00"})
ser.validate()
self.assertTrue("created" not in ser.cleaned_data)
def testModelSerialization(self):
class DeepInner(db.EmbeddedDocument):
value = db.StringField()
class Inner(db.EmbeddedDocument):
value = db.StringField()
deep = db.EmbeddedDocumentField(DeepInner)
class Col(db.Document):
value = db.StringField()
excluded_field = db.StringField(default="excluded")
created = db.DateTimeField(default=datetime.datetime.now)
inner = db.EmbeddedDocumentField(Inner)
Col.objects.delete()
Col.objects.create(value="1", inner={"value": "inner1", "deep": {"value": "123"}})
Col.objects.create(value="2", inner={"value": "inner2"})
class Serializer(ModelSerializer):
method_field = fields.MethodField("test")
renamed = fields.ForeignKeyField(document_fieldname="inner__deep__value")
def test(self, doc):
return doc.value
class Meta:
model = Col
fields = ("value", "created", "method_field")
fk_fields = ("inner__value", "inner__deep__value")
data = Serializer(Col.objects.all()).to_python()
for item in data:
self.assertTrue("value" in item)
self.assertEqual(item["value"], item["method_field"])
self.assertTrue(type(item["created"]), datetime.datetime)
self.assertEqual(item["renamed"], item["inner__deep__value"])
:return:
"""
next_bus = None
if len(data) > 0 and len(data[0].mode_list) > 0:
first_bus_route = data[0].mode_list[0]
if isinstance(first_bus_route, BuswayMode):
next_bus = main_component.search_service.get_next_bus(
first_bus_route.heading_from, first_bus_route.heading_to, station
)
return next_bus
@meloentjoer.route("search", methods=["POST"])
def search_route():
json_return = request.get_json()
source = json_return["source"]
destination = json_return["destination"]
data = main_component.search_service.get_direction(source, destination)
next_bus = __get_next_bus(data, source)
rendered_element = render_template("response.html", entries=data, next_bus=next_bus)
return jsonify(data=rendered_element)
@meloentjoer.route("/")
def index():
return render_template("autocomplete.html", host_url=main_component.general_config.get_host_url())
meloentjoer_app = Flask(__name__)
meloentjoer_app.register_blueprint(meloentjoer, url_prefix="/")
import logging
from flask.app import Flask
from apps.config.apps_config import db_session, log_file
app = Flask(__name__)
from apps.billing.views import mod as billingModule
from apps.login.views import mod as loginModule
app.register_blueprint(billingModule)
app.register_blueprint(loginModule)
@app.teardown_appcontext
def shutdown_session(exception=None):
log.info("----------------- IN Shutdown session --------------")
db_session.remove()
log.info("----------------- AFter RemoveShutdown session --------------")
logging.basicConfig(filename=log_file, level=logging.DEBUG)
log = logging.getLogger()
import json
from flask import Blueprint, render_template
from flask.app import Flask
meloentjoer = Blueprint('meloentjoer', __name__)
@meloentjoer.route('/retrieve/<string:word>')
def retrieve_route(word):
word_list = ['ABCDE', 'EFGHI']
return json.dumps(word_list)
@meloentjoer.route('/')
def index():
return render_template('autocomplete.html', host_url='http://127.0.0.1:5000/meloentjoer/')
meloentjoer_app = Flask(__name__)
meloentjoer_app.register_blueprint(meloentjoer, url_prefix='/meloentjoer')
from flask.ext.sqlalchemy import SQLAlchemy
import wtforms_json
from chisubmit.backend.webapp.auth.testing import TestingAuth
from chisubmit.backend.webapp.auth import set_auth
from chisubmit.backend.webapp.auth.ldap import LDAPAuth
wtforms_json.init()
app = Flask(__name__)
app.json_encoder = CustomJSONEncoder
db = SQLAlchemy(app)
import chisubmit.backend.webapp.api.views
app.register_blueprint(api_endpoint, url_prefix='/api/v0')
class ChisubmitAPIServer(object):
def __init__(self, debug):
self.app = app
self.db = db
self.debug = debug
if self.debug:
self.debug = True
self.app.config["DEBUG"] = True
self.app.config["TESTING"] = True
self.app.config["SQLALCHEMY_RECORD_QUERIES"] = True
else:
# coding: utf-8
from flask.app import Flask
import admin
import blog
app = Flask(__name__)
app.register_blueprint(blog.mod, url_prefix='/blog')
app.register_blueprint(admin.mod, url_prefix='/admin')
@app.teardown_appcontext
def shutdown_session(exception=None):
from database import db_session
db_session.remove()
@app.template_filter('strftime')
def filter_strftime(_datetime):
return _datetime.strftime('%Y-%m-%d %H:%M:%S')
if __name__ == '__main__':
app.run(debug=True)
