예제 #1
0
파일: entity.py 프로젝트: rohe/fedservice
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
예제 #2
0
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
예제 #3
0
def create_app(spark_context, app):
    global recommendationengine
    recommendationengine = RecommendationEngine(spark_context, app)

    app = Flask(__name__)
    app.register_blueprint(main)
    return app
예제 #4
0
파일: wsgi.py 프로젝트: its-dirg/ALservice
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
예제 #5
0
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
예제 #7
0
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
예제 #8
0
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
예제 #9
0
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
예제 #10
0
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
예제 #11
0
    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
예제 #12
0
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
예제 #13
0
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
예제 #14
0
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
예제 #15
0
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
예제 #16
0
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
예제 #17
0
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
예제 #18
0
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")
예제 #19
0
파일: app.py 프로젝트: jkakavas/loidc-op
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
예제 #20
0
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)
예제 #21
0
파일: __init__.py 프로젝트: Calvin-CS/csweb
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
예제 #22
0
파일: app.py 프로젝트: leehanchung/btc_dash
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)
예제 #23
0
파일: app.py 프로젝트: rembish/homebank-wui
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
예제 #24
0
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
예제 #25
0
파일: application.py 프로젝트: rohe/floop
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
예제 #26
0
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
예제 #27
0
파일: __init__.py 프로젝트: hekun97/MIS
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
예제 #28
0
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)
예제 #30
0
    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
예제 #31
0
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
예제 #32
0
파일: app.py 프로젝트: rembish/homebank-wui
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
예제 #33
0
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
예제 #34
0
파일: app.py 프로젝트: SUNET/se-leg-op
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
예제 #35
0
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)
예제 #36
0
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
예제 #37
0
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
예제 #38
0
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"])
예제 #39
0
    :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="/")
예제 #40
0
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()
예제 #41
0
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')
예제 #42
0
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:
예제 #43
0
파일: app.py 프로젝트: gengv/mantis
# 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)