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!"
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
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
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()
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']),
})
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
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')
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'])
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
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"]),
},
)
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>'
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
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
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
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
def initdatabase():
print("Initializing database. Please make sure all tables are deleted before executing this command.")
db = SQLAlchemy()
db.init_app(application)
database_initialization()
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)
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
def setup(app):
global db
db = SQLAlchemy(app)
import server.models.user
import server.models.meeting
db.create_all()
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
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()
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()
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)
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
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
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']),
})
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)
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
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
'''------------------------------------------------------------------------------------------'''
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)
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(
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
#### 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
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
# -*- 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():
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
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)
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:
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
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
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:
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
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)
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',
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)
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)
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
# ------------------
# 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
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",
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
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
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)
# -*- 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
# 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='')
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)
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
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)})
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)
