예제 #1
0
def create_app(config_filename):
    app = Flask(__name__)
    app.config.from_object(config_filename)

    # import database model
    from app.users.model import Users

    db.init_app(app)

    with app.app_context():
        db.create_all()

    # Blueprint
    # [User Module]
    from app.users.api import user_bp
    app.register_blueprint(user_bp, url_prefix='/user')

    @app.before_request
    def before_request():
        ip = request.remote_addr
        url = request.url

    # [CORS]
    @app.after_request
    def after_request(response):
        response.headers.add('Access-Control-Allow-Origin', '*')
        if request.method == 'OPTIONS':
            response.headers[
                'Access-Control-Allow-Methods'] = 'DELETE, GET, POST, PUT'
            headers = request.headers.get('Access-Control-Request-Headers')
            if headers:
                response.headers['Access-Control-Allow-Headers'] = headers
        return response

    return app
예제 #2
0
    def setUp(self):
        self.app = create_app()
        self.client = self.app.test_client()
        with self.app.app_context():
            db.drop_all()
            db.create_all()
            self.user = User()
            self.user.id = self.user_id
            self.user.email, self.user.name, self.user.secret = \
                '*****@*****.**', self.publisher_name, 'super_secret'

            self.publisher = Publisher(name=self.publisher_name)

            association = PublisherUser(role=UserRoleEnum.owner)
            association.publisher = self.publisher

            metadata = MetaDataDB(name=self.package)
            self.publisher.packages.append(metadata)
            self.user.publishers.append(association)

            db.session.add(self.user)
            db.session.commit()
        response = self.client.post(self.jwt_url,
                                    data=json.dumps({
                                        'username': self.publisher_name,
                                        'secret': 'super_secret'
                                    }),
                                    content_type='application/json')
        data = json.loads(response.data)
        self.jwt = data['token']
        self.auth = "bearer %s" % self.jwt
예제 #3
0
def create_app() -> Flask:
    """
    Application factory, returns an instance of a Flask App.
    This could be expanded to receive a config object.
    """
    # Retrieve the database uri
    db_uri = os.environ.get("db_uri")
    if not db_uri:
        raise SystemError("No db_uri set in the environment")

    logger.info("Creating application with database uri %s", db_uri)
    app = Flask(__name__)
    app.config['SQLALCHEMY_DATABASE_URI'] = db_uri
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
    app.url_map.strict_slashes = False
    db.init_app(app)

    # Add a cli command for populating data
    app.cli.add_command(seed)

    # Create all the models in our database if they aren't already present
    # TODO: This should be handled externally, outside of our ORM.
    with app.app_context():
        db.create_all()

    # For region related endpoints
    app.add_url_rule('/api/regions', methods=['GET'], view_func=RegionController.get_regions)

    return app
예제 #4
0
def create_app():
    app = Flask(__name__)

    app.config['DEBUG'] = True
    app.config['SQLALCHEMY_DATABASE_URI'] = f'postgresql://{POSTGRES["user"]}:{POSTGRES["pw"]}@{POSTGRES["host"]}: \
            {POSTGRES["port"]}/{POSTGRES["db"]}'
    app.config['CORS_HEADERS'] = 'Content-Type'
    app.secret_key = SECRET_KEY

    from app.database import db, migrate
    from app.logic.services.auth_service import argon2, login_manager
    from app.http.router import cors, router

    db.init_app(app)
    migrate.init_app(app, db)
    argon2.init_app(app)
    login_manager.init_app(app)
    cors.init_app(app)

    app.app_context().push()

    db.create_all()

    app.register_blueprint(router)

    return app
예제 #5
0
파일: tests.py 프로젝트: Anioko/flask-bones
def make_db(num_users=5):
    db.drop_all()
    db.create_all()

    users = [
        User(
            admin_username,
            admin_email,
            admin_password,
            fake.ipv4(),
            active=True,
            is_admin=True
        )
    ]
    for _ in range(num_users):
        u = User(
            fake.userName(),
            fake.email(),
            fake.word() + fake.word(),
            fake.ipv4()
        )
        users.append(u)
    [db.session.add(x) for x in users]

    db.session.commit()
 def setUp(self):
     """Define las variables del test e inicializa la app"""
     self.app = create_app("testing")
     self.app_context = self.app.app_context()
     self.app_context.push()
     self.client = self.app.test_client(use_cookies=True)
     db.create_all()
예제 #7
0
 def setUp(self):
     self.app = app.test_client()
     with app.app_context():
         db.session.close()
         db.drop_all()
         db.create_all()
         setup_db(db.session)
예제 #8
0
파일: manage.py 프로젝트: zacatac/emailer
def createdb():
    """ Creates a database with all of the tables defined in
        your Alchemy models
    """
    # print(app.config['SQLALCHEMY_DATABASE_URI'])
    db.create_all()
    manager_role = Role(name='management')
    employee_role = Role(name='employee')
    db.session.add(manager_role)
    db.session.add(employee_role)
    db.session.commit()
    if not Users.query.filter(Users.username=='user007').first():

        user1 = Users(username='******', email='*****@*****.**', active=True,
                     password=user_manager.hash_password('Password1'))
        user1.roles.append(employee_role)
        # user1.set_role()
        db.session.add(user1)
        db.session.commit()

        user2 = Users(username='******', email='*****@*****.**', active=True,
                     password=user_manager.hash_password('Password1'))
        # user2.set_role()
        user2.roles.append(manager_role)
        db.session.add(user2)
        db.session.commit()

        user3 = Users(username='******', email='*****@*****.**', active=True,
                     password=user_manager.hash_password('Password1'))
        # user3.set_role()
        user3.roles.append(manager_role)
        db.session.add(user3)
        db.session.commit()
예제 #9
0
    def setup_class(self):
        self.publisher_one = 'test_publisher1'
        self.publisher_two = 'test_publisher2'
        self.package_one = 'test_package1'
        self.package_two = 'test_package2'
        self.package_three = 'test_package3'
        self.app = create_app()
        self.app.app_context().push()

        with self.app.test_request_context():
            db.drop_all()
            db.create_all()

            user1 = User(name=self.publisher_one)
            publisher1 = Publisher(name=self.publisher_one)
            association1 = PublisherUser(role=UserRoleEnum.owner)
            association1.publisher = publisher1
            user1.publishers.append(association1)

            user2 = User(name=self.publisher_two)
            publisher2 = Publisher(name=self.publisher_two)
            association2 = PublisherUser(role=UserRoleEnum.owner)
            association2.publisher = publisher2
            user2.publishers.append(association2)

            metadata1 = Package(name=self.package_one)
            tag1 = PackageTag(descriptor=dict(name='test_one'))
            metadata1.tags.append(tag1)
            publisher1.packages.append(metadata1)

            db.session.add(user1)
            db.session.add(user2)
            db.session.commit()
예제 #10
0
def create_database():
    db.drop_all()
    db.create_all()
    with open('asf_list.json') as bee_file:
        bees = json.load(bee_file)
        db.session.bulk_save_objects([BeeModel(**bee) for bee in bees])
        db.session.commit()
예제 #11
0
def init_database():
    # Create the database and the database table
    db.create_all()

    # Fake data
    documents = [
        Document(
            text='It was the best of times, it was the worst of times',
            title='A Tale of Two Cities',
        ),
        Document(
            text='<html><head /><body><article>Hello</article></body></html>',
            title='A random HTML page',
        ),
        Document(
            text='<p>A fragment of text',
            title='A fragment of text',
        ),
        Document(
            text='',
            title='Doc1',
        ),
    ]
    map(lambda doc: db.session.add(doc), documents)
    db.session.add(documents[0])

    # Commit the changes for the users
    db.session.commit()

    yield db  # this is where the testing happens!

    db.drop_all()
예제 #12
0
def db(app):
    _db.app = app
    _db.create_all()

    yield _db

    _db.drop_all()
예제 #13
0
 def setUp(self):
     self.app = create_app()
     # self.app.app_context().push()
     self.client = self.app.test_client()
     with self.app.app_context():
         db.drop_all()
         db.create_all()
         self.user = User()
         self.user.id = self.user_id
         self.user.email, self.user.name, self.user.secret = \
             '*****@*****.**', self.publisher, 'super_secret'
         publisher = Publisher(name=self.publisher)
         association = PublisherUser(role="OWNER")
         association.publisher = publisher
         self.user.publishers.append(association)
         db.session.add(self.user)
         db.session.commit()
     response = self.client.post(self.jwt_url,
                                 data=json.dumps({
                                     'username': self.publisher,
                                     'secret': 'super_secret'
                                 }),
                                 content_type='application/json')
     data = json.loads(response.data)
     self.jwt = data['token']
예제 #14
0
    def setUp(self):
        self.app_context = self.app.app_context()
        self.app_context.push()
        db.create_all()

        login(self.client, os.getenv('LOGIN_USERNAME'),
              os.getenv('LOGIN_PASSWORD'))
예제 #15
0
 def setUp(self):
     self.app = create_app(AuthTestConfig)
     self.app_context = self.app.test_request_context()
     self.app_context.push()
     db.app = self.app
     db.create_all()
     self.client = self.app.test_client(use_cookies=True)
예제 #16
0
 def test_adds_local_urls(self):
     descriptor = {
         'name': 'test',
         'resources': [{
             'path': 'first.csv'
         }, {
             'path': 'second.csv'
         }]
     }
     with self.app.app_context():
         db.drop_all()
         db.create_all()
         publisher = Publisher(name=self.publisher)
         metadata = Package(name=self.package)
         metadata.descriptor = json.dumps(descriptor)
         publisher.packages.append(metadata)
         db.session.add(publisher)
         db.session.commit()
     response = self.client.get('/api/package/%s/%s'%\
                                (self.publisher, self.package))
     catalog = Catalog(json.loads(response.data))
     dataset = catalog.construct_dataset('http://example.com/')
     self.assertEqual(dataset.\
                      get('resources')[0].get('localurl'),
     'http://example.com/api/dataproxy/demo/demo-package/r/first.csv')
     self.assertEqual(dataset.\
                      get('resources')[1].get('localurl'),
     'http://example.com/api/dataproxy/demo/demo-package/r/second.csv')
예제 #17
0
    def setUp(self):
        self.app = create_app()
        self.app.app_context().push()
        with self.app.test_request_context():
            db.drop_all()
            db.create_all()
            self.pub1_name = 'pub1'
            self.pub2_name = 'pub2'
            self.pub1 = Publisher(name=self.pub1_name)
            self.pub2 = Publisher(name=self.pub2_name)
            self.pub1.packages.append(
                Package(name='pack1',
                        descriptor='{"title": "pack1 details one"}',
                        readme="Big readme one"))
            self.pub1.packages.append(
                Package(name='pack2',
                        descriptor='{"title": "pack2 details two"}',
                        readme="Big readme two"))
            self.pub1.packages.append(
                Package(name='pack3',
                        descriptor='{"title": "pack3 details three"}'))

            self.pub2.packages.append(
                Package(name='pack4',
                        descriptor='{"title": "pack4 details four"}'))
            self.pub2.packages.append(
                Package(name='pack5',
                        descriptor='{"title": "pack5 details five"}'))
            self.pub2.packages.append(
                Package(name='pack6',
                        descriptor='{"title": "pack6 details six"}'))
            db.session.add(self.pub1)
            db.session.add(self.pub2)
            db.session.commit()
예제 #18
0
    def setUp(self):
        self.publisher = 'demo'
        self.package = 'demo-package'
        self.publisher_one = 'test_publisher1'
        self.publisher_two = 'test_publisher2'
        self.package_one = 'test_package1'
        self.package_two = 'test_package2'
        self.package_three = 'test_package3'
        self.descriptor = json.loads(open('fixtures/datapackage.json').read())
        self.app = create_app()
        self.app.app_context().push()

        with self.app.test_request_context():
            db.drop_all()
            db.create_all()

            create_test_package(self.publisher, self.package, self.descriptor)

            user1 = User(name=self.publisher_one)
            publisher1 = Publisher(name=self.publisher_one)
            association1 = PublisherUser(role=UserRoleEnum.owner)
            association1.publisher = publisher1
            user1.publishers.append(association1)

            user2 = User(name=self.publisher_two)
            publisher2 = Publisher(name=self.publisher_two)
            association2 = PublisherUser(role=UserRoleEnum.owner)
            association2.publisher = publisher2
            user2.publishers.append(association2)

            metadata1 = Package(name=self.package_one)
            tag1 = PackageTag(descriptor=dict(name='test_one'))
            metadata1.tags.append(tag1)
            publisher1.packages.append(metadata1)

            metadata2 = Package(name=self.package_two)
            tag2 = PackageTag(descriptor=dict(name='test_two'))
            metadata2.tags.append(tag2)
            publisher1.packages.append(metadata2)

            metadata3 = Package(name=self.package_one)
            tag3 = PackageTag(descriptor=dict(name='test_three'))
            metadata3.tags.append(tag3)
            publisher2.packages.append(metadata3)

            metadata4 = Package(name=self.package_two)
            tag4 = PackageTag(descriptor=dict(name='test_four'))
            metadata4.tags.append(tag4)
            publisher2.packages.append(metadata4)

            metadata5 = Package(name=self.package_three)
            tag5 = PackageTag(descriptor=dict(name='test_four'))
            metadata5.tags.append(tag5)
            publisher2.packages.append(metadata5)

            db.session.add(user1)
            db.session.add(user2)

            db.session.commit()
예제 #19
0
 def setUp(self):
     self.publisher = 'test_publisher'
     self.package = 'test_package'
     self.app = create_app()
     self.client = self.app.test_client()
     with self.app.app_context():
         db.drop_all()
         db.create_all()
예제 #20
0
def db(app):
    _db.app = app
    with app.app_context():
        _db.create_all()

    yield _db

    _db.drop_all()
예제 #21
0
 def setUpClass(cls):
     """Run once at the start"""
     app = create_app(test_config)
     db.app = app  # hack for using db.init_app(app) in app/__init__.py
     db.drop_all()
     db.create_all()
     populate_db()
     cls.app = app
예제 #22
0
파일: reset_db.py 프로젝트: Zabanaa/haytham
def _reset_db():
    from flask_migrate import upgrade, stamp

    db.drop_all()
    db.engine.execute('DROP TABLE IF EXISTS alembic_version;')
    db.create_all()
    stamp()
    upgrade()
예제 #23
0
 def setup_class(self):
     self.app = create_app()
     self.client = self.app.test_client()
     with self.app.app_context():
         db.drop_all()
         db.create_all()
         base.make_fixtures(self.app, self.package, self.publisher,
                            self.user_id)
예제 #24
0
 def test_throw_error_if_role_is_invalid(self):
     with self.app.test_request_context():
         db.drop_all()
         db.create_all()
         publisher = Publisher(name='test_pub_id')
         association = PublisherUser()
         association.publisher = publisher
         self.assertRaises(ValueError, association.role, "NOT_MEMBER")
예제 #25
0
    def setUp(self):
        self.app = create_app()
        self.client = self.app.test_client()
        with self.app.app_context():
            self.bucket_name = self.app.config['S3_BUCKET_NAME']
            db.drop_all()
            db.create_all()
            self.user = User()
            self.user.id = self.user_id
            self.user.email, self.user.name, self.user.secret = \
                '*****@*****.**', self.publisher_name, 'super_secret'

            self.publisher = Publisher(name=self.publisher_name)

            association = PublisherUser(role=UserRoleEnum.owner)
            association.publisher = self.publisher

            metadata = Package(name=self.package)
            self.publisher.packages.append(metadata)
            self.user.publishers.append(association)

            self.user_not_allowed = User()
            self.user_not_allowed.id = self.user_not_allowed_id
            self.user_not_allowed.email, self.user_not_allowed.name, \
                self.user_not_allowed.secret = \
                '*****@*****.**', self.user_not_allowed_name, 'super_secret'

            self.publisher_not_allowed = Publisher(
                name=self.user_not_allowed_name)

            association_not_allowed = PublisherUser(role=UserRoleEnum.owner)
            association_not_allowed.publisher = self.publisher_not_allowed

            metadata = Package(name=self.package)
            self.publisher_not_allowed.packages.append(metadata)
            self.user_not_allowed.publishers.append(association_not_allowed)

            self.user_member = User()
            self.user_member.id = self.user_member_id
            self.user_member.email, self.user_member.name, self.user_member.secret = \
                '*****@*****.**', self.user_member_name, 'super_secret'

            association_member = PublisherUser(role=UserRoleEnum.member)
            association_member.publisher = self.publisher
            self.user_member.publishers.append(association_member)

            db.session.add(self.user)
            db.session.add(self.user_not_allowed)
            db.session.commit()
        response = self.client.post(self.jwt_url,
                                    data=json.dumps({
                                        'username': self.publisher_name,
                                        'secret': 'super_secret'
                                    }),
                                    content_type='application/json')
        data = json.loads(response.data)
        self.jwt = data['token']
        self.auth = "bearer %s" % self.jwt
예제 #26
0
 def test_throw_404_if_user_not_exists(self):
     with self.app.app_context():
         db.drop_all()
         db.create_all()
     auth = "bearer %s" % self.jwt
     response = self.client.post(self.url,
                                 data=json.dumps(dict()),
                                 headers=dict(Authorization=auth))
     self.assertEqual(404, response.status_code)
예제 #27
0
def flask_app():
    app = create_app(environment='testing')
    from app.database import db

    with app.app_context():
        db.create_all()
        yield app
        db.session.close_all()
        db.drop_all()
 def setUp(self):
     self.app = create_app()
     self.client = self.app.test_client()
     with self.app.app_context():
         db.drop_all()
         db.create_all()
         base.make_fixtures(self.app, self.package, self.publisher,
                            self.user_id)
         self.jwt = base.get_valid_token(self.publisher)
         self.jwt1 = base.get_valid_token('test1')
예제 #29
0
 def setUp(self):
     self.user = '******'
     self.email = 'email'
     self.full_name = 'Demo'
     self.app = create_app()
     self.app.app_context().push()
     with self.app.test_request_context():
         db.drop_all()
         db.create_all()
         db.session.commit()
예제 #30
0
def db(app):
    _db.app = app

    with app.app_context():
        _db.create_all()

    yield _db

    _db.session.close()
    _db.drop_all()
예제 #31
0
def client():
    with app.test_client() as client:
        app_ctx = app.app_context()
        app_ctx.push()
        db.drop_all()
        db.create_all()
        yield client
        db.session.remove()
        db.drop_all()
        app_ctx.pop()
예제 #32
0
def db(app):
    """A database for the tests."""
    _db.app = app
    with app.app_context():
        _db.create_all()

    yield _db

    # Explicitly close DB connection
    _db.session.close()
    _db.drop_all()
예제 #33
0
def db(app):
    """A database for the tests."""
    _db.app = app
    with app.app_context():
        _db.create_all()

    yield _db

    # Explicitly close DB connection
    _db.session.close()
    _db.drop_all()
예제 #34
0
def create_app(config=None):

    app = Flask(__name__)

    # If no config file is passed in on the command line:
    if config is None:
        #config = os.path.join(app.root_path, os.environ.get('FLASK_APPLICATION_SETTINGS'))
        config = os.path.join(os.path.dirname( __file__ ), "../config/", "config.cfg")

    app.config.from_pyfile(config)

    # Secret key needed to use sessions.
    app.secret_key = app.config['SECRET_KEY']

    app.mail = Mail(app)

    # Initialize SQL Alchemy and Flask-Login
    # Instantiate the Bcrypt extension
    db.init_app(app)
    if (app.config['CREATE_SCHEMA']):
        with app.app_context():
            db.create_all()
    login_manager.init_app(app)
    bcrypt.init_app(app)

    # CSRF protection
    csrf.init_app(app)

    # Web assets (js, less)
    assets = Environment(app)
    js = Bundle('js/main.js',
                filters='jsmin', output='gen/bundle.js')
    assets.register('js_all', js)

    # Automatically tear down SQLAlchemy
    @app.teardown_request
    def shutdown_session(exception=None):
        db.session.remove()

    @app.before_request
    def before_request():
        g.user = current_user

    app.register_blueprint(unauthenticated)
    app.register_blueprint(authenticated)
    app.register_blueprint(users)

    return app
예제 #35
0
def create_db(num_users=5):
    """Creates database tables and populates them."""
    db.create_all()
    populate_db(num_users=num_users)
예제 #36
0
def init_db():
    db.create_all()
예제 #37
0
 def create_app(self):
     app = create_app('config.TestConfig')
     with app.app_context():
         db.drop_all()
         db.create_all()
     return app
예제 #38
0
def createdb():
    db.init_app(current_app)
    db.create_all()
예제 #39
0
def create_db():
	db.create_all()
예제 #40
0
def create_db():
    """Creates the database."""
    db.create_all()
# -*- coding: utf-8 -*-

from flask import Flask, jsonify

from flask_sqlalchemy import SQLAlchemy
from flask_restless import APIManager
import datetime
import os

from app import config

app = Flask(__name__)
# init config
app.config.from_object(config)

# init views
from app import views

#init database
from app.database import db, restless
from app.model import user, system
db.create_all()

from app import db_init
db_init.init()


if __name__ == "__main__":
	app.run(debug=True)