def init(app):
    print "starting db test..."
    db = SQLAlchemy(app)

    from app.models import User

    engine = create_engine(app.config['SQLALCHEMY_DATABASE_URI'], echo=False)
    # if not database_exists(engine.url):
    #     print "Database not found, creating new..."
    #     create_database(engine.url)
    #     print "Done!"

    Session = sessionmaker(bind=engine)
    session = Session()

    db.create_all()

    print "creating user 'admin'..."
    admin = User("admin", "*****@*****.**")
    session.add(admin)
    session.commit()
    print "done!"

    print "Users found in database:"
    for instance in session.query(User):
        print instance.username
        print "destroying user..."
        session.delete(instance)
        session.commit()
        print "done!"

    print "db test done!"
Пример #2
0
class TestFSA(FlaskTestBase):
    """Tests which use models defined using Flask-SQLAlchemy instead of pure
    SQLAlchemy.

    """

    def setup(self):
        """Creates the Flask application, the APIManager, the database, and the
        Flask-SQLAlchemy models.

        """
        super(TestFSA, self).setup()
        self.db = SQLAlchemy(self.flaskapp)

        class Person(self.db.Model):
            id = self.db.Column(self.db.Integer, primary_key=True)

        self.Person = Person
        self.db.create_all()

    def teardown(self):
        """Drops all tables from the temporary database."""
        self.db.drop_all()
        unregister_fsa_session_signals()

    def test_init_app(self):
        manager = APIManager(flask_sqlalchemy_db=self.db)
        manager.create_api(self.Person)
        manager.init_app(self.flaskapp)
        response = self.app.get('/api/person')
        assert response.status_code == 200
Пример #3
0
    def display_queries(response):
      """Display database queries

      Prints out SQL queries, EXPLAINs for queries above slow_threshold, and
      a final count of queries after every HTTP request
      """
      slow_threshold = 0.5  # EXPLAIN queries that ran for more than 0.5s
      queries = get_debug_queries()
      logger.info("Total queries: %s", len(queries))
      if report_type == 'count':
        return response
      # We have to copy the queries list below otherwise queries executed
      # in the for loop will be appended causing an endless loop
      for query in queries[:]:
        if report_type == 'slow' and query.duration < slow_threshold:
          continue
        logger.info(
            "%.8f %s\n%s\n%s",
            query.duration,
            query.context,
            query.statement,
            query.parameters)
        is_select = bool(re.match('SELECT', query.statement, re.I))
        if query.duration > slow_threshold and is_select:
          try:
            statement = "EXPLAIN " + query.statement
            engine = SQLAlchemy().get_engine(app)
            result = engine.execute(statement, query.parameters)
            logger.info(tabulate(result.fetchall(), headers=result.keys()))
          except:  # pylint: disable=bare-except
            logger.warning("Statement failed: %s", statement, exc_info=True)
      return response
Пример #4
0
class FlaskSQLAlchemyTestBase(FlaskTestBase, DatabaseMixin):
    """Base class for tests that use Flask-SQLAlchemy (instead of plain
    old SQLAlchemy).

    If Flask-SQLAlchemy is not installed, the :meth:`.setup` method will
    raise :exc:`nose.SkipTest`, so that each test method will be
    skipped individually.

    """

    def setup(self):
        super(FlaskSQLAlchemyTestBase, self).setup()
        if not has_flask_sqlalchemy:
            raise SkipTest('Flask-SQLAlchemy not found.')
        self.flaskapp.config['SQLALCHEMY_DATABASE_URI'] = self.database_uri()
        # This is to avoid a warning in earlier versions of
        # Flask-SQLAlchemy.
        self.flaskapp.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
        # Store some attributes for convenience and so the test methods
        # read more like the tests for plain old SQLAlchemy.
        self.db = SQLAlchemy(self.flaskapp)
        self.session = self.db.session

    def teardown(self):
        """Drops all tables and unregisters Flask-SQLAlchemy session
        signals.

        """
        self.db.drop_all()
        unregister_fsa_session_signals()
Пример #5
0
def sql_select():
    statement = request.args['sql']
    params = request.args['params']

    # Validate hash
    hash = hashlib.sha1(
        current_app.config['SECRET_KEY'] + statement + params).hexdigest()
    if hash != request.args['hash']:
        return abort(406)

    # Make sure it is a select statement
    if not statement.lower().strip().startswith('select'):
        return abort(406)

    params = json.loads(params)

    engine = SQLAlchemy().get_engine(current_app)

    result = engine.execute(statement, params)
    return g.debug_toolbar.render('panels/sqlalchemy_select.html', {
        'result': result.fetchall(),
        'headers': result.keys(),
        'sql': format_sql(statement, params),
        'duration': float(request.args['duration']),
    })
Пример #6
0
def webapp(request):
    app = Flask(__name__)
    app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite://"
    app.config["PROPAGATE_EXCEPTIONS"] = True

    db = SQLAlchemy(app)

    class Object(db.Model):
        id = db.Column(db.Integer, primary_key=True)
        field1 = db.Column(db.Integer)
        field2 = db.Column(db.Integer)

    db.create_all()

    @app.route("/objects")
    @paginated_view
    @sorted_view(allowed_fields=["id", "field1"])
    def view_objects():
        return Object.query

    @app.route("/objects_different_renderer")
    @paginated_view(renderer=lambda obj: {"id_value": obj.id})
    def view_objects_different_renderer():
        return Object.query

    @app.route("/objects_limited_page_size")
    @paginated_view(max_page_size=10, default_page_size=5)
    def view_objects_limited_page_size():
        return Object.query

    @app.route("/objects_no_count")
    @paginated_view(max_page_size=10, default_page_size=5, include_count=False)
    def view_objects_no_count():
        return Object.query


    @app.route("/objects_by_field2")
    @paginated_view
    @sorted_view(default="-field2")
    def view_objects_by_field2():
        return Object.query


    num_objects = 100
    field1_values = list(range(num_objects))
    random.shuffle(field1_values)
    field2_values = list(range(num_objects))
    random.shuffle(field2_values)

    for field1_value, field2_value in zip(field1_values, field2_values):
        db.session.add(Object(field1=field1_value, field2=field2_value))

    db.session.commit()

    returned = App(app)
    returned.num_objects = num_objects
    returned.activate()
    request.addfinalizer(returned.deactivate)

    return returned
Пример #7
0
    def test_flask(self):
        app = Flask(__name__)
        db = SQLAlchemy(app)
        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'

        class Cities(db.Model):
            __tablename__ = 'users'

            id = Column(Integer, primary_key=True)
            name = Column(String)
            population = Column(Integer)

            def __init__(self, name, population):
                self.name = name
                self.population = population
                
        app.config['TESTING'] = True
        app = app.test_client()
        db.create_all()

        city = Cities("Cordoba", 1000000)
        db.session.add(city)
        city = Cities("Rafaela", 99000)
        db.session.add(city)
        db.session.commit()

        query_string = '{ "sort": { "population" : "desc" } }'
        results = elastic_query(Cities, query_string)
        assert(results[0].name == 'Cordoba')
Пример #8
0
def run(the_config):
    global base, app, config, db, cookie_serializer
    config = the_config

    app.secret_key = config['flask']['session_secret_key']
    app.debug = config['flask']['debug']
    # app.redis = redis.StrictRedis(host='localhost', port=6379, db=0)

    # Cookie serializer
    cookie_serializer = URLSafeTimedSerializer(app.secret_key)

    # Configure the database before importing any other packages that
    # use DB models.
    app.config['SQLALCHEMY_DATABASE_URI'] = config['db']['uri']
    app.config['SQLALCHEMY_ECHO'] = config['db']['echo']
    db = SQLAlchemy(app)

    # Import all models so SQLAlchemy knows about their relationships
    import siege.models

    # Create all models
    db.create_all()

    # Import the views to enable Flask handlers
    import siege.views

    populate_initial_data(config, db)

    gevent.spawn(game_management_greenlet)
    socketio.run(app, host=config['flask']['bind'])
Пример #9
0
class TestFlaskSqlalchemy(FlaskTestBase):
    """Tests for deleting resources defined as Flask-SQLAlchemy models instead
    of pure SQLAlchemy models.

    """

    def setup(self):
        """Creates the Flask-SQLAlchemy database and models."""
        super(TestFlaskSqlalchemy, self).setup()
        self.db = SQLAlchemy(self.flaskapp)
        self.session = self.db.session

        class Person(self.db.Model):
            id = self.db.Column(self.db.Integer, primary_key=True)

        self.Person = Person
        self.db.create_all()
        self.manager = APIManager(self.flaskapp, flask_sqlalchemy_db=self.db)
        self.manager.create_api(self.Person, methods=['DELETE'])

    def teardown(self):
        """Drops all tables and unregisters Flask-SQLAlchemy session signals.

        """
        self.db.drop_all()
        unregister_fsa_session_signals()

    def test_delete(self):
        """Tests for deleting a resource."""
        person = self.Person(id=1)
        self.session.add(person)
        self.session.commit()
        response = self.app.delete('/api/person/1')
        assert response.status_code == 204
        assert self.Person.query.count() == 0
Пример #10
0
def sql_explain():
    statement = request.args["sql"]
    params = request.args["params"]
    bind = request.args.get("bind")
    bind = bind if bind != "" else None

    # Validate hash
    hash = hashlib.sha1(current_app.config["SECRET_KEY"] + statement + params).hexdigest()
    if hash != request.args["hash"]:
        return abort(406)

    # Make sure it is a select statement
    if not statement.lower().strip().startswith("select"):
        return abort(406)

    params = json.loads(params)

    engine = SQLAlchemy().get_engine(current_app, bind)

    if engine.driver == "pysqlite":
        query = "EXPLAIN QUERY PLAN %s" % statement
    else:
        query = "EXPLAIN %s" % statement

    result = engine.execute(query, params)
    return g.debug_toolbar.render(
        "panels/sqlalchemy_explain.html",
        {
            "result": result.fetchall(),
            "headers": result.keys(),
            "sql": format_sql(statement, params),
            "duration": float(request.args["duration"]),
        },
    )
Пример #11
0
def test_flask_sqlalchemy():
    from flask.ext.sqlalchemy import SQLAlchemy as FlaskSQLAlchemy

    app = Flask(__name__)
    app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///'
    db = FlaskSQLAlchemy(app)

    class UserMixin(object):
        email = db.Column(db.Unicode(300))

        def __init__(self, login, email):
            self.login = login
            self.email = email
            self.password = '******'

    class RoleMixin(object):
        description = db.Column(db.UnicodeText)

    auth = authcode.Auth(SECRET_KEY, db=db, UserMixin=UserMixin, RoleMixin=RoleMixin)
    authcode.setup_for_flask(auth, app)
    User = auth.User

    db.create_all()
    user = User(u'meh', u'*****@*****.**')
    db.session.add(user)
    db.session.commit()

    assert user.login == u'meh'
    assert user.email == u'*****@*****.**'
    assert hasattr(user, 'password')
    assert hasattr(user, 'last_sign_in')
    assert repr(user) == '<User meh>'
Пример #12
0
def connect(config, app):
    dbconfig = {
        'user': config.DB_USERNAME,
        'password': config.DB_PASSWORD,
        'database': config.DB_DATABASE_NAME,
        'host': config.DB_HOST,
        'port': config.DB_PORT,
    }
    dbconfig.update(config.DB_OPTIONS)
    app.config['SQLALCHEMY_DATABASE_URI'] = "mysql://" + str(config.DB_USERNAME) + ":" + str(config.DB_PASSWORD) + "@127.0.0.1:" + str(config.DB_PORT) + "/" + config.DB_DATABASE_NAME
    for name, obj in inspect.getmembers(models):
        if inspect.isclass(obj):
            setattr(app, name, obj)
    db = SQLAlchemy(app)

    def _query_db(query, data=None):
        result = db.session.execute(text(query), data)
        if query[0:6].lower() != 'select':
            app.db.session.commit()
            return True
        else:
            return result

    def _get_one(query, data=None):
        result = db.session.execute(text(query), data).fetchone()
        return result

    db.query_db = _query_db
    db.get_one = _get_one
    return db
Пример #13
0
def create_app():
    app = Flask(__name__)
    app.config.from_object('over_achiever.config')
    db = SQLAlchemy(app, metadata=models.metadata)
    db.create_all()
    resources.db = app.db = db

    oauth = OAuth(app)
    github = oauth.remote_app(
        'github',
        consumer_key='507e57ab372adeb8051b',
        consumer_secret='08a7dbaa06ac16daab00fac53724ee742c8081c5',
        request_token_params={'scope': 'user:email'},
        base_url='https://api.github.com/',
        request_token_url=None,
        access_token_method='POST',
        access_token_url='https://github.com/login/oauth/access_token',
        authorize_url='https://github.com/login/oauth/authorize'
    )

    # set the token getter for the auth client
    github._tokengetter = lambda: session.get('github_token')
    resources.github = app.github = github

    api = Api(app)
    resource_map = (
        (User, '/v1.0/users'),
        (Goal, '/v1.0/goals'),
    )

    for resource, route in resource_map:
        api.add_resource(resource, route)

    return app
Пример #14
0
def createDB():
  #sqliteDBPath = os.path.abspath(os.path.join(os.getcwd(), 'data', 't3.db'))
  #app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + sqliteDBPath
  app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
  app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://'+app.config['DATABASE']['user']+':'+app.config['DATABASE']['passwd']+'@'+app.config['DATABASE']['host']+':'+str(app.config['DATABASE']['port'] or '')+'/'+app.config['DATABASE']['schema']
  db = SQLAlchemy(app, session_options={
    #'autoflush': False,
    #'autocommit': False,
    'expire_on_commit': False
  })
  
  dbConfig = {
    'mysql': {
      'passive_updates': True,
      'cascade_all': 'all, delete, delete-orphan'
    },
    'sqlite': {
      'passive_updates': False,
      'cascade_all': 'all, delete, delete-orphan'
    },
  }
  dbConfigSet = app.config['SQLALCHEMY_DATABASE_URI'].split(':')[0]
  
  db._config = type('CustomConfiguration', (object,), dbConfig[dbConfigSet])
  
  return db
Пример #15
0
class GangaAPI(unittest.TestCase):
    def setUp(self):
        app.config.from_object('settings')
        self.db = SQLAlchemy(app)
        self.db.create_all()
        self.client = app.test_client()

    def tearDown(self):
        self.db.session.remove()
        self.db.drop_all()

    def test_create_user_missing_password(self):
        data = { 'email': '*****@*****.**', }
        response = self.client.put('/user/', data=data)
        assert response.status_code, 200

    def test_create_user_missing_email(self):
        data = { 'email': '',
                 'password': 123, }
        response = self.client.put('/user/', data=data)
        assert response.status_code, 200

    def test_create_user_successfully(self):
        data = { 'email': '*****@*****.**',
                 'password': 123, }
        response = self.client.put('/user/', data=data)
        assert response.status_code, 200

    def test_create_user_duplicate(self):
        data = { 'email': '*****@*****.**',
                 'password': 123, }
        response = self.client.put('/user/', data=data)
        assert response.status_code, 400
Пример #16
0
def initdatabase():
	print("Initializing database. Please make sure all tables are deleted before executing this command.")

	db = SQLAlchemy()
	db.init_app(application)

	database_initialization()
Пример #17
0
def createHerokuDb():
	"""
	Import this function and the database models into 'heroku run python' to create database on heroku
	"""
		app = Flask(__name__)
		app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['dbUrl']
		db = SQLAlchemy(app)
		db.create_all()
def configure_database(app):
    "Database configuration should be set here"

    db = SQLAlchemy(app)
    #import web.models

    db.create_all()
    db.metadata.create_all(bind=db.engine)
Пример #19
0
def init(db_filename):
  """Initializes the database."""
  app = Flask(__name__)
  app.config['SQLALCHEMY_DATABASE_URI'] = db_filename
  app.config['SESSION_TYPE'] = 'filesystem'
  db = SQLAlchemy(app)
  db.create_all()
  return db
Пример #20
0
def setup(app):
    global db
    db = SQLAlchemy(app)

    import server.models.user
    import server.models.meeting

    db.create_all()
Пример #21
0
def init_db(app):
    global db
    db = SQLAlchemy(app)

    from models import User
    if app.config['DEBUG']:
        print 'Recreating all db'
        db.create_all() # I DO create everything
Пример #22
0
def init_db(app):
    global db, migrate
    db = SQLAlchemy(app)
    migrate = Migrate(app, db)

    from models import Component, Incident, Page, User, Update
    db.create_all()
    db.session.commit()
Пример #23
0
class TestCase(unittest.TestCase):

    def setUp(self):
        #app.config['TESTING'] = True
        #app.config['WTF_CSRF_ENABLED'] = False
        #app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
        #app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'test.db')
        #self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'

        '''
        self.app = Flask(__name__)
        self.app.config['TESTING'] = True
        self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'test.db')
        self.db = SQLAlchemy(self.app)
        with self.app.app_context():
            self.db.session.remove()
            self.db.drop_all()
            self.db.create_all()
        '''

        self.app = Flask(__name__)
        self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'test.db')
        self.app.config['TESTING'] = True
        #self.db = SQLAlchemy(self.app)
        self.db = SQLAlchemy()
        self.db.init_app(self.app)
        with self.app.app_context():
            db.session.remove()
            db.drop_all()
            db.create_all()

    def tearDown(self):
        pass

        #self.db.session.remove()
        #self.db.drop_all()
        #os.unlink(os.path.join(basedir, 'test.db'))

        '''
        self.app = Flask(__name__)
        self.db = SQLAlchemy(self.app)
        #db.init_app(self.app)
        with self.app.app_context():
            self.db.drop_all()
        '''
        #print 'tearDown'

    def test_user(self):
        u = Usuario()
        u.nome = 'Gold'
        u.login = '******'
        u.ativo = True
        u.email = '*****@*****.**'
        u.set_senha('gold')
        self.db.session.add(u)
        self.db.session.commit()
        gold = Usuario.query.filter_by(login='******').first()
Пример #24
0
    def setUp(self):
        temp = tempfile.mkstemp()
        self.temp = temp
        self.db_fd = temp[0]
        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///%s' % temp[1]
        app.config['TESTING'] = True
        self.app = app.test_client()

        SQLAlchemy.create_all(db)
Пример #25
0
def create_app():
    app = Flask(__name__)
    app.config.from_object('config')
    global db
    db = SQLAlchemy(app)
    db.init_app(app)
    register_routes(app)
    register_error_handler(app)
    register_logger(app)
    return app
Пример #26
0
  def apply_driver_hacks(self, app, info, options):
    SAExtension.apply_driver_hacks(self, app, info, options)

    if info.drivername == 'sqlite':
      connect_args = options.setdefault('connect_args', {})

      if 'isolation_level' not in connect_args:
        # required to support savepoints/rollback without error. It disables
        # implicit BEGIN/COMMIT statements made by pysqlite (a COMMIT kills all
        # savepoints made).
        connect_args['isolation_level'] = None
Пример #27
0
def sql_select():
    statement, params = load_query(request.args['query'])
    engine = SQLAlchemy().get_engine(current_app)

    result = engine.execute(statement, params)
    return g.debug_toolbar.render('panels/sqlalchemy_select.html', {
        'result': result.fetchall(),
        'headers': result.keys(),
        'sql': format_sql(statement, params),
        'duration': float(request.args['duration']),
    })
Пример #28
0
    def init_app(self, app):
        SQLAlchemy.init_app(self, app)
        if app.testing:
            self.testing_scoped_session()

        @event.listens_for(Engine, "connect")
        def on_connect(dbapi_connection, connection_record):
            self.set_sqlite_pragma(dbapi_connection, connection_record)

        @testing_run_start.connect_via(ANY, weak=False)
        def on_testing_start(app):
            self.on_testing_start(app)
Пример #29
0
    def create_app(self):
        app = Flask(__name__)
        app.debug = True
        app.secret_key = 'very secret'
        db = SQLAlchemy()
        db.init_app(app)

        class Model(db.Model):
            __tablename__ = 'model'
            id = db.Column(db.Integer, primary_key=True)

        self.Model = Model
        return app
Пример #30
0
class Config:

    def __init__(self,name="CR"):
        self.app = Flask(name)
        self.db = SQLAlchemy(self.app)
        pm.install_as_MySQLdb()
        self.app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://*****:*****@localhost/shuracr?charset=utf8'
        self.db.init_app(self.app)
    def get_current_db(self):

        return self.db
    def get_current_app(self):
        return self.app
Пример #31
0
'''------------------------------------------------------------------------------------------'''
import os
from flask import Flask, render_template, request
from flask.ext.sqlalchemy import SQLAlchemy
'''------------------------------------------------------------------------------------------'''
'''------------------------------------------------------------------------------------------'''
app = Flask(__name__)
'''------------------------------------------------------------------------------------------'''
'''------------------------------------------------------------------------------------------'''
#conectarBaseDatos
'''Realiza la conexion a la base de datos
Este metodo se encarga de realizar la conexion a la base de datos'''
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL']
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['DEBUG'] = True
bd = SQLAlchemy(app)
'''------------------------------------------------------------------------------------------'''
'''------------------------------------------------------------------------------------------'''


class Maquina(bd.Model):
    id_so = bd.Column(bd.Integer, primary_key=True)
    kernel = bd.Column(bd.String(100), unique=True)
    release = bd.Column(bd.String(100), unique=True)
    nodename = bd.Column(bd.String(100), unique=True)
    kernelv = bd.Column(bd.String(100), unique=True)
    machine = bd.Column(bd.String(100), unique=True)
    processor = bd.Column(bd.String(100), unique=True)
    so = bd.Column(bd.String(100), unique=True)
    hardware = bd.Column(bd.String(100), unique=True)
    user_logged = bd.Column(bd.String(100), unique=True)
Пример #32
0
from flask.ext.sqlalchemy import SQLAlchemy

from flask.ext import admin, wtf
from flask.ext.admin.contrib import sqlamodel
from flask.ext.admin.contrib.sqlamodel import filters

# Create application
app = Flask(__name__)

# Create dummy secrey key so we can use sessions
app.config['SECRET_KEY'] = '123456790'

# Create in-memory database
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.sqlite'
app.config['SQLALCHEMY_ECHO'] = True
db = SQLAlchemy(app)


# Create models
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True)
    email = db.Column(db.String(120), unique=True)

    # Required for administrative interface
    def __unicode__(self):
        return self.username


# Create M2M table
post_tags_table = db.Table(
Пример #33
0
from flask.ext.sqlalchemy import SQLAlchemy
from rootio.extensions import db

#telephony_server = Flask("ResponseServer")
#telephony_server.debug = True
#telephony_server.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@localhost/rootio'

db = SQLAlchemy('postgresql://*****:*****@localhost/rootio')

lines = dq.query.all()

print lines
Пример #34
0
#### config ####
################

application = Flask(__name__)
application.config.from_object('config.ProductionConfig')

####################
#### extensions ####
####################

login_manager = LoginManager()
login_manager.init_app(application)
bcrypt = Bcrypt(application)
mail = Mail(application)
toolbar = DebugToolbarExtension(application)
db = SQLAlchemy(application)

####################
#### blueprints ####
####################
with application.app_context():
    from main.views import main_blueprint
    from user.views import user_blueprint
    application.register_blueprint(main_blueprint)
    application.register_blueprint(user_blueprint)

####################
#### flask-login ####
####################

from models import User
Пример #35
0
import os, gevent
from psycogreen.gevent import patch_psycopg
if os.fork is gevent.fork:
    patch_psycopg()
from datetime import timedelta
from sqlalchemy.orm import joinedload
from flask.ext.sqlalchemy import SQLAlchemy

from pager.config import config
from pager.app import app
from pager.libs import extend
from pager.libs.timezone import now

db = SQLAlchemy(app)


class Mixins(object):
    id = db.Column(db.Integer, primary_key=True)

    created = db.Column(db.DateTime(True), default=now, nullable=False)
    updated = db.Column(db.DateTime(True),
                        default=now,
                        onupdate=now,
                        nullable=False)

    @property
    def is_new(self):
        return id is None

    def to_json(self):
        created = self.created and self.created.isoformat() or None
Пример #36
0
# -*- coding: utf-8 -*-

from flask.ext.sqlalchemy import SQLAlchemy
import datetime
from flask import Flask, request, render_template, redirect, Response
from hashlib import sha256
import MySQLdb

db = SQLAlchemy()

class Exploit(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    text = db.Column(db.Text)
    is_read = db.Column(db.Boolean)
    def __init__(self, text):
        self.text = text
        self.is_read = False

class OneTimePassword(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    password =  db.Column(db.String(250), index=True, unique=True)
    def __init__(self, password):
        self.password = password

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+mysqldb://honeypot@localhost/honeypot?charset=utf8&use_unicode=0'
app.debug = False
db.init_app(app)

@app.route('/', methods=['GET', 'POST'])
def index():
Пример #37
0
def create_app(test_config=None):                   # For automated tests
    # Setup Flask and read config from ConfigClass defined above
    app = Flask(__name__)
    app.config.from_object(__name__+'.ConfigClass')

    # Load local_settings.py if file exists         # For automated tests
    try: app.config.from_object('local_settings')
    except: pass

    # Load optional test_config                     # For automated tests
    if test_config:
        app.config.update(test_config)

    # Initialize Flask extensions
    db = SQLAlchemy(app)                            # Initialize Flask-SQLAlchemy
    babel = Babel(app)                              # Initialize Flask-Babel
    mail = Mail(app)                                # Initialize Flask-Mail

    # Define the User data model. Make sure to add flask.ext.user UserMixin!!
    class User(db.Model, UserMixin):
        id = db.Column(db.Integer, primary_key=True)

        # User authentication information
        username = db.Column(db.String(50), nullable=True, unique=True)
        password = db.Column(db.String(255), nullable=False, server_default='')
        reset_password_token = db.Column(db.String(100), nullable=False, server_default='')

        # User email information
        email = db.Column(db.String(255), nullable=True, unique=True)
        confirmed_at = db.Column(db.DateTime())

        # User information
        active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0')
        first_name = db.Column(db.String(100), nullable=False, server_default='')
        last_name = db.Column(db.String(100), nullable=False, server_default='')

        # Relationships
        roles = db.relationship('Role', secondary='user_roles',
                backref=db.backref('users', lazy='dynamic'))

    # Define UserEmail DataModel.
    class UserEmail(db.Model):
        id = db.Column(db.Integer, primary_key=True)
        user_id = db.Column(db.Integer, db.ForeignKey('user.id'))

        # User email information
        email = db.Column(db.String(255), nullable=True, unique=True)
        confirmed_at = db.Column(db.DateTime())
        is_primary = db.Column(db.Boolean(), nullable=False, default=False)

        # Relationship
        user = db.relationship('User', uselist=False)

    class UserInvitation(db.Model):
        __tablename__ = 'user_invite'
        id = db.Column(db.Integer, primary_key=True)
        email = db.Column(db.String(255), nullable=False)
        # save the user of the invitee
        invited_by_user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
        # token used for registration page to identify user registering
        token = db.Column(db.String(100), nullable=False, server_default='')


    # Define the Role data model
    class Role(db.Model):
        id = db.Column(db.Integer(), primary_key=True)
        name = db.Column(db.String(50), unique=True)

    # Define the UserRoles data model
    class UserRoles(db.Model):
        id = db.Column(db.Integer(), primary_key=True)
        user_id = db.Column(db.Integer(), db.ForeignKey('user.id', ondelete='CASCADE'))
        role_id = db.Column(db.Integer(), db.ForeignKey('role.id', ondelete='CASCADE'))

    # Reset all the database tables
    db.create_all()

    # Setup Flask-User
    db_adapter = SQLAlchemyAdapter(db,  User, UserInvitationClass=UserInvitation)
    user_manager = UserManager(db_adapter, app)

    # Create regular 'member' user
    if not User.query.filter(User.username=='member').first():
        user = User(username='******', email='*****@*****.**', active=True,
                password=user_manager.hash_password('Password1'), confirmed_at=datetime.datetime.utcnow())
        db.session.add(user)
        db.session.commit()

    # Create 'user007' user with 'secret' and 'agent' roles
    if not User.query.filter(User.username=='user007').first():
        user1 = User(username='******', email='*****@*****.**', active=True,
                password=user_manager.hash_password('Password1'))
        user1.roles.append(Role(name='secret'))
        user1.roles.append(Role(name='agent'))
        db.session.add(user1)
        db.session.commit()

    # The '/' page is accessible to anyone
    @app.route('/')
    def home_page():
        # if current_user.is_authenticated():
        #     return user_profile_page()
        return render_template_string("""
            {% extends "base.html" %}
            {% block content %}
            <h2>{%trans%}Home Page{%endtrans%}</h2>
            <p><a href="{{ url_for('user.login') }}">{%trans%}Sign in{%endtrans%}</a></p>
            {% endblock %}
            """)

    # The '/profile' page requires a logged-in user
    @app.route('/user/profile')
    @login_required                                 # Use of @login_required decorator
    @confirm_email_required
    def user_profile_page():
        return render_template_string("""
            {% extends "base.html" %}
            {% block content %}
            <h2>{%trans%}Profile Page{%endtrans%}</h2>
            <p> {%trans%}Hello{%endtrans%}
                {{ current_user.username or current_user.email }},</p>
            <p> <a href="{{ url_for('user.change_username') }}">
                {%trans%}Change username{%endtrans%}</a></p>
            <p> <a href="{{ url_for('user.change_password') }}">
                {%trans%}Change password{%endtrans%}</a></p>
            <p> <a href="{{ url_for('user.invite') }}">
                {%trans%}Invite User{%endtrans%}</a></p>
            <p> <a href="{{ url_for('user.logout') }}?next={{ url_for('user.login') }}">
                {%trans%}Sign out{%endtrans%}</a></p>
            {% endblock %}
            """)

    # The '/special' page requires a user that has the 'special' AND ('sauce' OR 'agent') role.
    @app.route('/special')
    @roles_required('secret', ['sauce', 'agent'])   # Use of @roles_required decorator
    def special_page():
        return render_template_string("""
            {% extends "base.html" %}
            {% block content %}
            <h2>{%trans%}Special Page{%endtrans%}</h2>
            {% endblock %}
            """)

    # For testing only
    app.db = db
    app.UserEmailClass = UserEmail

    return app
Пример #38
0
from serializers import ItemSerializer, PersonSerializer


class Settings:
    DB_NAME = "inventory.db"
    # Put the db file in project root
    SQLALCHEMY_DATABASE_URI = "sqlite:///{0}".format(DB_NAME)
    DEBUG = True

app = Flask(__name__)
app.config.from_object(Settings)

### Models ###

db = SQLAlchemy()
db.init_app(app)

class Person(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    firstname = db.Column(db.String(80), nullable=False)
    lastname = db.Column(db.String(80), nullable=False)
    created = db.Column(db.DateTime, default=datetime.utcnow)

    @property
    def n_items(self):
        return len(self.items)

    def __repr__(self):
        return "<Person '{0} {1}'>".format(self.firstname, self.lastname)
Пример #39
0
from flask import Flask, render_template, request
from flask.ext.sqlalchemy import SQLAlchemy
import os
import datetime

app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = os.environ['DATABASE_URL']
db = SQLAlchemy(app)

#http://blog.y3xz.com/blog/2012/08/16/flask-and-postgresql-on-heroku
#hello


class Logger(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    ip_address = db.Column(db.String(400))
    timestamp = db.Column(db.DateTime, default=datetime.datetime.now)

    def __init__(self, ip_address):
        self.ip_address = ip_address

    def __repr__(self):
        return '<ip_addr %r>' % self.ip_address


@app.route("/index")
@app.route("/")
def index():
    if request.headers.getlist("X-Forwarded-For"):
        ip = request.headers.getlist("X-Forwarded-For")[0]
    elif request.access_route:
Пример #40
0
from automated_survey_flask.config import config_env_files
from flask import Flask

from flask.ext.sqlalchemy import SQLAlchemy

db = SQLAlchemy()
app = Flask(__name__)


def prepare_app(environment='development', p_db=db):
    app.config.from_object(config_env_files[environment])
    p_db.init_app(app)
    # load views by importing them
    from . import views
    return app


def save_and_commit(item):
    db.session.add(item)
    db.session.commit()


db.save = save_and_commit
Пример #41
0
from flask.ext.sqlalchemy import SQLAlchemy
import datetime

db = SQLAlchemy()


class Carrier(db.Model):
    """
    This stores information about the various phone carrier providers.
        carrier_name: the string of the name
        domain: the domain used for emailing
        users: the users who use this carrier
    """
    __tablename__ = 'cellCarrierInfo'
    __table_args__ = {'mysql_engine': 'InnoDB'}
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    carrier_name = db.Column(db.Text, nullable=False)
    domain = db.Column(db.Text, nullable=False)
    users = db.relationship('User', backref='carrier')

    def __init__(self, name, domain):
        self.carrier_name = name
        self.domain = domain

    def __str__(self):
        return str(self.id) + ") " + self.carrier_name + ", " + self.domain


class User(db.Model):
    """
    Holds notify users' information
Пример #42
0
import os
from flask import Flask, Blueprint, render_template, g
from flask import jsonify, redirect, request, url_for
from flask.ext.sqlalchemy import SQLAlchemy
from config import SETUP, APP, API, PREFERRED_URL_SCHEME
from yams_api.utils.logger import logfile

API_HOST = "%s://%s:%s" % (PREFERRED_URL_SCHEME, API.LISTEN_HOST,
                           API.LISTEN_PORT)

app = Flask(__name__)
app.config.from_object(os.environ.get("FLASK_CONFIG") or "config")

# this should only be used for db operations related to the web interface.
# if you are associating models with this, you more than likely want the API DB.
app_db = SQLAlchemy(app)
db = SQLAlchemy(app)

navigation_dictionary_list = [{
    "link": "/",
    "text": "/index"
}, {
    "link": API_HOST,
    "text": "api"
}]

# blueprint routes
from yams.core.dev import core_dev_blueprints
for bp in core_dev_blueprints:

    if bp.url_prefix == '/' or not bp.url_prefix:
Пример #43
0
def get_db():  # noqa
    """Get modified db object."""
    database = SQLAlchemy()

    class String(database.String):
        """Simple subclass of sqlalchemy.orm.String which provides a default
    length for `String` types to satisfy MySQL
    """

        # pylint: disable=too-few-public-methods
        # this class is just to set the default string length and is not meant to
        # do anything else, so it does not need any other public methods.

        def __init__(self, length=None, *args, **kwargs):
            # TODO: Check for MySQL and only apply when needed
            if length is None:
                length = 250
            super(String, self).__init__(length, *args, **kwargs)

    database.String = String

    database.session.plain_commit = database.session.commit

    database.session.commit_hooks_enable_flag = CommitHooksEnableFlag()

    def pre_commit_hooks():
        """All pre commit hooks handler."""
        with benchmark("pre commit hooks"):
            if not database.session.commit_hooks_enable_flag:
                return
            database.session.flush()
            if hasattr(database.session, "reindex_set"):
                database.session.reindex_set.indexing_hook()

    def post_commit_hooks():
        """All post commit hooks handler."""
        with benchmark("post commit hooks"):
            if not database.session.commit_hooks_enable_flag:
                return
            # delete flask caches in order to avoid
            # using cached instances after commit
            if hasattr(flask.g, "user_cache"):
                del flask.g.user_cache
            if hasattr(flask.g, "user_creator_roles_cache"):
                del flask.g.user_creator_roles_cache
            from ggrc.models.hooks import acl
            acl.after_commit()

    database.session.post_commit_hooks = post_commit_hooks
    database.session.pre_commit_hooks = pre_commit_hooks

    def hooked_commit(*args, **kwargs):
        """Commit override function.

    This function is meant for a single after commit hook that should only be
    used for ACL propagation.
    """
        database.session.pre_commit_hooks()
        with benchmark("plain commit"):
            database.session.plain_commit(*args, **kwargs)
        database.session.post_commit_hooks()

    database.session.commit = hooked_commit

    return database
Пример #44
0
from flask import Flask, render_template, url_for
from flask.ext.admin import Admin, BaseView, expose

from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.admin.contrib.sqla import ModelView
from flask.ext.admin.contrib.fileadmin import FileAdmin
from flask.ext.login import LoginManager
from flask.ext.openid import OpenID

SERVER_NAME = '0.0.0.0'
SERVER_PORT = 5000

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///soundboardtags.sqlite'
app.config['SECRET_KEY'] = '123456790'
db = SQLAlchemy(app)

lm = LoginManager()
lm.init_app(app)
oid = OpenID(app, os.path.join(basedir, 'tmp'))

pygame.mixer.init()

sound_tags_table = db.Table(
    'sound_tags', db.Model.metadata,
    db.Column('sound_id', db.Integer, db.ForeignKey('sound.id')),
    db.Column('tag_id', db.Integer, db.ForeignKey('tag.id')))


class Tag(db.Model):
    id = db.Column(db.Integer, primary_key=True)
Пример #45
0
from flask import *
from flask.ext.sqlalchemy import SQLAlchemy
from forms import *
from md5 import md5
import json

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db'
app.secret_key = "T\xd6\\p\xf9\x8e\xd6\xc0TL\xdf\x92\x080Q\xbf\xf0)\xd1&'\xeb\xb0\x05"
db = SQLAlchemy(app)

library = db.Table(
    'library', db.Column('author_id', db.Integer, db.ForeignKey('author.id')),
    db.Column('book_id', db.Integer, db.ForeignKey('book.id')))


class Author(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(30))

    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return '<Author %r>' % self.name


class Book(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50))
    authors = db.relationship('Author',
Пример #46
0
from datetime import timedelta

import sqlalchemy.orm.exc
from flask import Flask, redirect, render_template, request, url_for
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.wtf import Form
from flask_admin import Admin
from flask_admin.contrib.sqla import ModelView
from wtforms import TextField, validators
from wtforms.fields.html5 import DateField
from wtforms.ext.sqlalchemy.fields import QuerySelectField, QuerySelectMultipleField

app = Flask(__name__)
app.config.from_object("config")
app.config.from_envvar('SOOKIE_SETTINGS', silent=True)
db = SQLAlchemy(app)
admin = Admin(app, name='sookie', template_mode='bootstrap3')


class Category(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50), unique=True)

    def __init__(self, name=None):
        self.name = name

    def __str__(self):
        return self.name

    def __repr__(self):
        return '<Category({!r})>'.format(self.name)
Пример #47
0
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy

app_tests = Flask(__name__)
app_tests.config[
    'SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://api2k15:@127.0.0.1:3306/nba_flask_test'
app_tests.config['WHOOSH_BASE'] = 'path_tests/to/whoosh/base'
db_tests = SQLAlchemy(app_tests)
Пример #48
0
from flask import Flask, request, Response
from flask import render_template, send_from_directory, url_for
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.mobility import Mobility
from logging import StreamHandler, DEBUG
import utility
import config

basedir = config.basedir
baseurl = config.baseurl

flask_app = Flask(__name__, template_folder='public/template')
flask_app.config.from_object('config')
db = SQLAlchemy(flask_app)
Mobility(flask_app)

file_handler = StreamHandler()
flask_app.logger.setLevel(DEBUG)  # set the desired logging level here
flask_app.logger.addHandler(file_handler)

import models
import controllers
import scripts
Пример #49
0
# ------------------
# Init application
# ------------------
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
import os

app_instance = Flask(__name__, static_url_path='')
app_instance.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app_instance.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app_instance.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('GGMATE_DB')

db = SQLAlchemy(app_instance)

import ggmate
Пример #50
0
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy

app = Flask(__name__)

# 配置数据库链接地址
app.config[
    "SQLALCHEMY_DATABASE_URI"] = "mysql://*****:*****@127.0.0.1:3306/manytomany9"
# 是否跟踪数据库的修改
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False

# 初始化数据库操作对象
db = SQLAlchemy(app)

# 学生与课程的对应表关系
# 一张表里面可以有多个主键,表示多个主键联结起来在当前这张表里面不能有重复数据,定义方式就是在多个字段后面添加  primary_key=True
tb_student_course = db.Table(
    "tb_student_course",
    db.Column("student_id", db.Integer, db.ForeignKey("student.id")),
    db.Column("course_id", db.Integer, db.ForeignKey("course.id")))


# 定义学生的模型
class Student(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64))

    # 表示当前学生选择的所有课程
    # secondary 指定多对多关联关系中的中间表
    courses = db.relationship("Course",
                              lazy="dynamic",
Пример #51
0
from datetime import datetime
from sqlalchemy.orm.exc import NoResultFound
from kvoter.app import app
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import UserMixin
import hashlib
from random import choice
from string import ascii_letters, digits

app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///kvoter.db"

db = SQLAlchemy(app)

roles_users = db.Table(
    'user_roles',
    db.Column('user_id', db.Integer(), db.ForeignKey('users.id')),
    db.Column('role_id', db.Integer(), db.ForeignKey('roles.id'))
)


class Candidate(db.Model):
    __tablename__ = 'candidates'

    id = db.Column(db.Integer(), primary_key=True)
    user_id = db.Column(db.Integer(), db.ForeignKey('users.id'))
    election_id = db.Column(db.Integer(), db.ForeignKey('elections.id'))

    def __init__(self, user_id, election_id):
        self.user_id = user_id
        self.election_id = election_id
Пример #52
0
    def __call__(self, environ, start_response):
        if self.script_name:
            environ['SCRIPT_NAME'] = self.script_name
            path_info = environ['PATH_INFO']
            if path_info.startswith(self.script_name):
                environ['PATH_INFO'] = path_info[len(self.script_name):]

        scheme = environ.get('HTTP_X_SCHEME', '')
        if scheme:
            environ['wsgi.url_scheme'] = scheme
        return self.app(environ, start_response)


app = Flask(__name__)
app.secret_key = "V=7Km+XXkg:}>4dT0('cV>Rp1TG82QEjah+X'v;^w:)a']y)^%"
db = app.db = SQLAlchemy(app)
models.register_base(db)

opts = app.opts = None
contest = app.contest = None

app.context_processor(context_processor)

app.register_blueprint(default)
app.register_blueprint(judge, url_prefix="/judge")


@app.before_request
def before_request():
    g.request_start_time = time.time()
    g.request_time = lambda: time.time() - g.request_start_time
Пример #53
0
    basedir, 'data.sqlite')  # 指定数据库URI
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app.config['MAIL_SERVER'] = 'smtp.qq.com'
app.config['MAIL_PORT'] = 587  # 465
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = os.environ.get('MAIL_USERNAME')
app.config['MAIL_PASSWORD'] = os.environ.get('MAIL_PASSWORD')
app.config['FLASKY_MAIL_SUBJECT_PREFIX'] = '[Flasky]'
app.config['FLASKY_MAIL_SENDER'] = 'Flasky Admin <' + app.config[
    'MAIL_USERNAME'] + '>'
app.config['FLASKY_ADMIN'] = os.environ.get('FLASKY_ADMIN')

manager = Manager(app)  # 命令行解析功能
bootstrap = Bootstrap(app)  # 集成Bootstrap框架
moment = Moment(app)  # 渲染日期和时间
db = SQLAlchemy(app)  # 创建数据库
mail = Mail(app)  # 初始化Flask-Mail

migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)


class NameForm(Form):
    name = StringField('What is your name?', validators=[Required()])
    submit = SubmitField('Submit')


class Role(db.Model):
    __tablename__ = 'roles'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)
Пример #54
0
# -*- coding: utf-8 -*-
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy

asem = Flask(__name__)
asem.config.from_object('config')
db = SQLAlchemy(asem)

from views import views
asem.debug = True
import sys
import os
import hashlib
import random
import time
from datetime import datetime

print "importing sha3"
import sha3

from flask.ext.sqlalchemy import SQLAlchemy

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from apper import *

user_db = SQLAlchemy(app)


#https://github.com/mrjoes/flask-admin/blob/master/examples/auth/app.py
class User(user_db.Model):
    id = user_db.Column(user_db.Integer, primary_key=True)
    first_name = user_db.Column(user_db.String(100))
    last_name = user_db.Column(user_db.String(100))
    login = user_db.Column(user_db.String(80), unique=True)
    email = user_db.Column(user_db.String(120))
    password = user_db.Column(user_db.String(400))
    salt = user_db.Column(user_db.String(400))

    # Flask-Login integration
    def is_authenticated(self):
        return True
Пример #56
0
# app.model
import datetime
from flask.ext.sqlalchemy import SQLAlchemy
from app.utils import escapeDatetime

db = SQLAlchemy()

owner_event_association = db.Table('owner_event_association',
    db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
    db.Column('event_id', db.Integer, db.ForeignKey('event.id'))
)

applicant_event_association = db.Table('applicant_event_association',
    db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
    db.Column('event_id', db.Integer, db.ForeignKey('event.id'))
)

participant_event_association = db.Table('participant_event_association',
    db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
    db.Column('event_id', db.Integer, db.ForeignKey('event.id'))
)

class User(db.Model):
    __tablename__ = 'user'

    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True)
    email = db.Column(db.String(120), unique=True)
    password = db.Column(db.String(20), default='')
    status = db.Column(db.String(50), default='')
    description = db.Column(db.String(500), default='')
Пример #57
0
from datetime import datetime

from flask.ext.login import UserMixin
from flask.ext.sqlalchemy import SQLAlchemy
from sqlalchemy.dialects.postgresql import JSON
import uuid64

from finance.exceptions import (AssetValueUnavailableException,
                                InvalidTargetAssetException)

db = SQLAlchemy()
JsonType = db.String().with_variant(JSON(), 'postgresql')


class CRUDMixin(object):
    """Copied from https://realpython.com/blog/python/python-web-applications-with-flask-part-ii/
    """  # noqa

    __table_args__ = {'extend_existing': True}

    id = db.Column(db.BigInteger,
                   primary_key=True,
                   autoincrement=False,
                   default=uuid64.issue())

    @classmethod
    def create(cls, commit=True, **kwargs):
        if 'id' not in kwargs:
            kwargs.update(dict(id=uuid64.issue()))
        instance = cls(**kwargs)
Пример #58
0
class TestFSA(FlaskTestBase):
    """Tests which use models defined using Flask-SQLAlchemy instead of pure
    SQLAlchemy.

    """

    def setUp(self):
        """Creates the Flask application, the APIManager, the database, and the
        Flask-SQLAlchemy models.

        """
        super(TestFSA, self).setUp()

        # initialize SQLAlchemy and Flask-Restless
        self.db = SQLAlchemy(self.flaskapp)

        # for the sake of brevity...
        db = self.db

        # declare the models
        class Computer(db.Model):
            id = db.Column(db.Integer, primary_key=True)
            name = db.Column(db.Unicode, unique=True)
            vendor = db.Column(db.Unicode)
            buy_date = db.Column(db.DateTime)
            owner_id = db.Column(db.Integer, db.ForeignKey('person.id'))
            owner = db.relationship('Person',
                                    backref=db.backref('computers',
                                                       lazy='dynamic'))

        class Person(db.Model):
            id = db.Column(db.Integer, primary_key=True)
            name = db.Column(db.Unicode, unique=True)
            age = db.Column(db.Float)
            other = db.Column(db.Float)
            birth_date = db.Column(db.Date)

        self.Person = Person
        self.Computer = Computer

        # create all the tables required for the models
        self.db.create_all()

    def tearDown(self):
        """Drops all tables from the temporary database."""
        self.db.drop_all()
        unregister_fsa_session_signals()

    def test_flask_sqlalchemy(self):
        """Tests that :class:`flask.ext.restless.APIManager` correctly exposes
        models defined using Flask-SQLAlchemy.

        """
        manager = APIManager(self.flaskapp, flask_sqlalchemy_db=self.db)

        # create three different APIs for the same model
        manager.create_api(self.Person, methods=['GET', 'POST'])
        manager.create_api(self.Person, methods=['PATCH'], url_prefix='/api2')
        manager.create_api(self.Person, methods=['GET'],
                           url_prefix='/readonly')

        # test that specified endpoints exist
        response = self.app.post('/api/person', data=dumps(dict(name='foo')))
        assert response.status_code == 201
        assert loads(response.data)['id'] == 1
        response = self.app.get('/api/person')
        assert response.status_code == 200
        assert len(loads(response.data)['objects']) == 1
        assert loads(response.data)['objects'][0]['id'] == 1
        response = self.app.patch('/api2/person/1',
                                  data=dumps(dict(name='bar')))
        assert response.status_code == 200
        assert loads(response.data)['id'] == 1
        assert loads(response.data)['name'] == 'bar'

        # test that the model is the same as before
        response = self.app.get('/readonly/person')
        assert response.status_code == 200
        assert len(loads(response.data)['objects']) == 1
        assert loads(response.data)['objects'][0]['id'] == 1
        assert loads(response.data)['objects'][0]['name'] == 'bar'

    def test_init_app(self):
        manager = APIManager()
        manager.init_app(self.flaskapp, flask_sqlalchemy_db=self.db)
        manager.create_api(self.Person, app=self.flaskapp)
        response = self.app.get('/api/person')
        assert response.status_code == 200

    def test_init_app_split_initialization(self):
        manager = APIManager(flask_sqlalchemy_db=self.db)
        manager.init_app(self.flaskapp)
        manager.create_api(self.Person, app=self.flaskapp)
        response = self.app.get('/api/person')
        assert response.status_code == 200
Пример #59
0
from flask import Flask, render_template, jsonify, abort, request
from flask.ext.restless import APIManager 
from flask.ext.sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config.from_pyfile('config.py')
db = SQLAlchemy(app)

class Developer(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Colum(db.String(20))
    hireDate = db.Colum(db.Date)
    focus = db.Colum(db.String(50))


def __init__(self, name, hireDate, focus)
    self.name = name
    self.hireDate = datetime.datetime.strptime(hireDate, %d%m%y).date()
    self.focus = focus

db.createAll()

@app.route('/dev/', methods=['GET'])
def index():
    return jsonify({ 'Developers': Developer.querry.get(id)})
Пример #60
0
from flask.ext.sqlalchemy import SQLAlchemy
from werkzeug import generate_password_hash, check_password_hash
from flaskblog import app
from config import WHOOSH_ENABLED
from math import ceil

db = SQLAlchemy(app)


class Admin(db.Model):
    __tablename__ = 'admin'
    id = db.Column(db.Integer, primary_key=True)
    userd = db.Column(db.String(100))

    def __init__(self, user):
        self.user = user

    def __repr__(self):
        return "<User: %s>" % (self.userd)

    def is_authenticated(self):
        return True

    def is_active(self):
        return True

    def is_anonymous(self):
        return False

    def get_id(self):
        return unicode(self.id)