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 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 __init__(self, app):
SQLAlchemy.__init__(self, app)
self.app = app
self.Model.to_dict = Database.__to_dict
self.Query.paginate = Database.__paginate
self.Query.to_page = Database.__to_page
self.Query.to_json = Database.__to_json
class TestDecorator(unittest.TestCase):
def setUp(self):
self.app = Flask(__name__)
self.app.config['TESTING'] = True
self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
self.db = SQLAlchemy()
self.db.init_app(self.app)
self.ctx = self.app.app_context()
self.ctx.push()
self.client = self.app.test_client()
class Product(self.db.Model):
"""Product model
"""
__tablename__ = "product"
id = self.db.Column('id', self.db.Integer, primary_key=True)
api_manager = APIManager(self.app, self.db, decorators=[a_decorator])
api_manager.register_api(Product)
def test_decorator(self):
with self.client as c:
rv = c.get(self.get_url('/products'), headers=self.get_headers())
self.assertTrue(rv.status_code == 404)
def get_url(self, resource_url):
return ''.join(['http://localhost', resource_url])
def get_headers(self):
headers = {'Content-Type': 'application/json',
'Accept': 'application/json'}
return headers
def setUp(self):
app = Flask("test")
db = FlaskSQLAlchemy(app)
self.session = db.session
self.osmalchemy = OSMAlchemy(db)
db.create_all()
OSMAlchemyModelTests.setUp(self)
def create_app():
""" Flask application factory """
# Setup Flask app and app.config
app = Flask(__name__)
app.config.from_object(__name__+'.ConfigClass')
# Initialize Flask extensions
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
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=False, 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=False, 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='')
# Create all database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User) # Register the User model
user_manager = UserManager(db_adapter, app) # Initialize Flask-User
# The Home page is accessible to anyone
@app.route('/')
@app.route('/<name>')
def home_page(name=None):
return render_template('root.html', name=name)
# The Members page is only accessible to authenticated users
@app.route('/members')
@app.route('/members/<name>')
@login_required # Use of @login_required decorator
def members_page(name=None):
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>Members page</h2>
<p>This page can only be accessed by authenticated users.</p><br/>
<p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p>
<p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p>
{% endblock %}
""",name=name)
return app
def get_db():
global _db
if not _db:
from flask_sqlalchemy import SQLAlchemy
_db = SQLAlchemy(current_app)
_db.init_app(current_app)
return _db
def create_app(self):
logging.getLogger('connexion.operation').setLevel('ERROR')
app = connexion.App(__name__, specification_dir='../swagger/')
app.add_api('swagger.yaml')
app.app.json_encoder = JSONEncoder
app.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/feed5.db'
db = SQLAlchemy(app.app)
db.init_app(app.app)
with app.app.app_context():
db.create_all()
return app.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
elif info.drivername.startswith('postgres'):
options.setdefault('client_encoding', 'utf8')
class TestBigInteger(TestCase):
def setUp(self):
self.app = Flask(__name__)
self.app.config['WHOOSHEE_MEMORY_STORAGE'] = True
self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
self.app.config['TESTING'] = True
self.app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
self.db = SQLAlchemy(self.app)
self.wh = Whooshee(self.app)
class User(self.db.Model):
id = self.db.Column(self.db.Integer, primary_key=True)
name = self.db.Column(self.db.String)
# Need to make sure BigInteger PK's can be created
@self.wh.register_model('title', 'content')
class Entry(self.db.Model):
id = self.db.Column(self.db.BigInteger, primary_key=True)
title = self.db.Column(self.db.String)
content = self.db.Column(self.db.Text)
user = self.db.relationship(User, backref = self.db.backref('entries'))
user_id = self.db.Column(self.db.Integer, self.db.ForeignKey('user.id'))
self.User = User
self.Entry = Entry
self.db.create_all(app=self.app)
self.u1 = User(name=u'chuck')
self.e1 = Entry(id=1000000000000, title=u'chuck nr. 1 article', content=u'blah blah blah', user=self.u1)
self.db.session.commit()
def tearDown(self):
self.db.drop_all(app=self.app)
def test_add(self):
# test that the add operation works for Big Integer PK
found = self.Entry.query.whooshee_search('blah blah blah').all()
self.assertEqual(len(found), 0)
self.db.session.add(self.e1)
self.db.session.commit()
found = self.Entry.query.whooshee_search('blah blah blah').all()
self.assertEqual(len(found), 1)
def _init_sql_db(app):
"""Configurable registeration of SqlAlchemy package.
:param app: The flask application object
:type app: flask.app.Flask
"""
if app.config.get("PACKAGE_SQLALCHEMY_ENABLED"):
global DB
if DB is None:
from flask_sqlalchemy import SQLAlchemy
DB = SQLAlchemy()
DB.init_app(app)
DB.app = app
app.DB = DB
def init_db(app):
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
# Define Role model
class Role(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# 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=False, 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='')
roles = db.relationship('Role', secondary='user_roles')
# FIXME: really not good performance wise
def is_admin(self):
for r in self.roles:
if r.name == "hacker":
return True
return False
# Define UserRoles 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'))
# Create all database tables
db.create_all()
user_db_adapter = SQLAlchemyAdapter(db, User) # Register the User model
return db, user_db_adapter, User, Role
def create_app():
""" Flask application factory """
# Setup Flask app and app.config
app = Flask(__name__)
app.config.from_object(__name__ + ".ConfigClass")
# Initialize Flask extensions
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
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=False, 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=False, 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="")
# Create all database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User) # Register the User model
user_manager = UserManager(db_adapter, app) # Initialize Flask-User
# The Home page is accessible to anyone
@app.route("/")
def home_page():
return render_template("home.html", story_list=[1, 2, 3, 4])
# The Members page is only accessible to authenticated users
@app.route("/members")
@login_required # Use of @login_required decorator
def members_page():
return render_template("members.html")
return app
def setup_method(self, method):
# Mock the event registering of Flask-SQLAlchemy. Currently there is no
# way of unregistering Flask-SQLAlchemy event listeners, hence the
# event listeners would affect other tests.
flexmock(_SessionSignalEvents).should_receive("register")
self.db = SQLAlchemy()
make_versioned()
versioning_manager.transaction_cls = TransactionFactory()
versioning_manager.options["native_versioning"] = uses_native_versioning()
self.create_models()
sa.orm.configure_mappers()
self.app = Flask(__name__)
# self.app.config['SQLALCHEMY_ECHO'] = True
self.app.config["SQLALCHEMY_DATABASE_URI"] = get_dns_from_driver(
get_driver_name(os.environ.get("DB", "sqlite"))
)
self.db.init_app(self.app)
self.app.secret_key = "secret"
self.app.debug = True
self.client = self.app.test_client()
self.context = self.app.test_request_context()
self.context.push()
self.db.create_all()
def setUp(self):
self.app = Flask(__name__)
self.app.config['WHOOSHEE_MEMORY_STORAGE'] = True
self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
self.app.config['TESTING'] = True
self.app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
self.db = SQLAlchemy(self.app)
self.wh = Whooshee(self.app)
class User(self.db.Model):
id = self.db.Column(self.db.Integer, primary_key=True)
name = self.db.Column(self.db.String)
# Need to make sure BigInteger PK's can be created
@self.wh.register_model('title', 'content')
class Entry(self.db.Model):
id = self.db.Column(self.db.BigInteger, primary_key=True)
title = self.db.Column(self.db.String)
content = self.db.Column(self.db.Text)
user = self.db.relationship(User, backref = self.db.backref('entries'))
user_id = self.db.Column(self.db.Integer, self.db.ForeignKey('user.id'))
self.User = User
self.Entry = Entry
self.db.create_all(app=self.app)
self.u1 = User(name=u'chuck')
self.e1 = Entry(id=1000000000000, title=u'chuck nr. 1 article', content=u'blah blah blah', user=self.u1)
self.db.session.commit()
def sql_select(explain=False):
statement, params = load_query(request.args['query'])
engine = SQLAlchemy().get_engine(current_app)
if explain:
if engine.driver == 'pysqlite':
statement = 'EXPLAIN QUERY PLAN\n%s' % statement
else:
statement = 'EXPLAIN\n%s' % statement
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 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
)
db = SQLAlchemy(app)
def _query_db(query, data=None):
result = db.session.execute(text(query), data)
if query[0:6].lower() == "select":
# if the query was a select
# convert the result to a list of dictionaries
list_result = [dict(r) for r in result]
# return the results as a list of dictionaries
return list_result
elif query[0:6].lower() == "insert":
# if the query was an insert, return the id of the
# commit changes
app.db.session.commit()
# row that was inserted
return result.lastrowid
else:
# if the query was an update or delete, return nothing and commit changes
app.db.session.commit()
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 set_db_engine(self,app,engine_uri):
'''Sample paramater:
app = Flask(__name__)
engine_uri = r'sqlite:///D:\auto\buffer\wbs.db'
'''
app.config['SQLALCHEMY_DATABASE_URI'] = engine_uri
self.db = SQLAlchemy(app)
print "Initial database: %s" %self.db.engine
def get_binds(self, app=None):
retval = BaseSQLAlchemy.get_binds(self, app)
bind = None
engine = self.get_engine(app, bind)
tables = self.get_tables_for_bind(bind)
retval.update(dict((table, engine) for table in tables))
return retval
class TestFlaskSQLAlchemy(FlaskSQLAlchemyTestBase):
"""Tests for updating 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()
# HACK During testing, we don't want the session to expire, so that we
# can access attributes of model instances *after* a request has been
# made (that is, after Flask-Restless does its work and commits the
# session).
session_options = dict(expire_on_commit=False)
# Overwrite the `db` and `session` attributes from the superclass.
self.db = SQLAlchemy(self.flaskapp, session_options=session_options)
self.session = self.db.session
class Person(self.db.Model):
id = self.db.Column(self.db.Integer, primary_key=True)
name = self.db.Column(self.db.Unicode)
self.Person = Person
self.db.create_all()
self.manager = APIManager(self.flaskapp, flask_sqlalchemy_db=self.db)
self.manager.create_api(self.Person, methods=['PATCH'])
def test_create(self):
"""Tests for creating a resource."""
person = self.Person(id=1, name=u'foo')
self.session.add(person)
self.session.commit()
data = {
'data': {
'id': '1',
'type': 'person',
'attributes': {
'name': u'bar'
}
}
}
response = self.app.patch('/api/person/1', data=dumps(data))
assert response.status_code == 204
assert person.name == 'bar'
def create_app():
from views import *
app = Flask(__name__, template_folder='templates')
app.config.from_object(config)
# Blueprints:x`
app.register_blueprint(blog)
app.register_blueprint(login)
app.register_blueprint(main_page)
app.register_blueprint(bower_blueprint)
db = SQLAlchemy(app)
db.create_all()
login_manager.init_app(app)
db.init_app(app)
return app
def create_app():
app = Flask(__name__)
app.config.from_object(config['default'])
config['default'].init_app(app)
moment.init_app(app)
bootstrap.init_app(app)
db = SQLAlchemy(app)
app.secret_key = 'SECRET_KEY'
db.init_app(app)
login_manager.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix = '/auth')
return app
def __init__(self, *args, **kwargs):
super(BaseTestCases.BaseTest, self).__init__(*args, **kwargs)
self.app = Flask(__name__)
self.app.config['WHOOSHEE_DIR'] = tempfile.mkdtemp()
self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
self.app.config['TESTING'] = True
self.app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
self.db = SQLAlchemy(self.app)
def create_app_main():
app = Flask(__name__)
app.config.from_object('bookhouse.main.config')
db = SQLAlchemy()
import bookhouse.core
bookhouse.core.app = app
bookhouse.core.db = db
db.init_app(app)
import bookhouse.models.user
import bookhouse.models.book
import bookhouse.main.views
import bookhouse.main.views.user
# import bookhouse.main.views.book
return app
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
from anyway.utilities import init_flask
from flask_sqlalchemy import SQLAlchemy
app = init_flask()
connectable = SQLAlchemy(app).engine
with connectable.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata
)
with context.begin_transaction():
context.run_migrations()
def __init__(self, app):
"""Initialize a new instance.
:param app: an instance of Flask application for which
dependencies are being configured
"""
self.app = app
# See http://flask-sqlalchemy.pocoo.org/2.1/config/
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
self.db = SQLAlchemy(app)
self.db.create_all()
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 create_app():
""" Flask application factory """
# Setup Flask app and app.config
app = Flask(__name__)
app.config.from_object(__name__+'.ConfigClass')
# Initialize Flask extensions
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
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=False, 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=False, 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='')
year = db.Column(db.Enum('Freshman', 'Sophomore', 'Junior', 'Senior', 'Masters', 'PhD'), nullable=True, server_default=None)
major = db.Column(db.String(100), nullable=True, server_default=None)
gpa = db.Column(db.Float(precision=2))
# Create all database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User) # Register the User model
user_manager = UserManager(db_adapter, app) # Initialize Flask-User
return app
def sqlalchemy_datastore(request, app, tmpdir):
from flask_sqlalchemy import SQLAlchemy
f, path = tempfile.mkstemp(prefix='flask-security-test-db', suffix='.db', dir=str(tmpdir))
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + path
db = SQLAlchemy(app)
roles_users = db.Table(
'roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
username = db.Column(db.String(255))
password = db.Column(db.String(255))
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
with app.app_context():
db.create_all()
request.addfinalizer(lambda: os.remove(path))
return SQLAlchemyUserDatastore(db, User, Role)
def setup_model(self):
time_now = datetime.now()
timestamp = time.mktime(time_now.timetuple())
float_default_value = 125.225
bool_default_value = True
self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
self.db = SQLAlchemy(self.app)
class TestModel(self.db.Model):
id = Column(Integer, primary_key=True)
col_int = Column(Integer, nullable=False)
col_str = Column(String(100), nullable=False)
col_float = Column(Float, nullable=False, default=float_default_value)
col_bool = Column(Boolean, nullable=False, server_default=text(str(int(bool_default_value))))
col_timestamp = Column(TIMESTAMP, nullable=False)
col_int_null = Column(Integer)
col_str_null = Column(String(100))
col_float_null = Column(Float)
col_bool_null = Column(Boolean)
col_timestamp_null = Column(TIMESTAMP)
self.TestModel = TestModel
self.db.create_all()
# ===== padding data =====
self.data1 = dict(
id=1,
col_int=10, col_str="a", col_float=1.5, col_bool=True, col_timestamp=time_now,
col_int_null=25, col_str_null=u"你好", col_float_null=0.001, col_bool_null=False,
col_timestamp_null=time_now)
self.result1 = self.data1.copy()
self.result1['col_timestamp'] = self.result1['col_timestamp_null'] = timestamp
# 通过只给 nullable=False 且没有默认值的字段赋值，可以测试 null 值以及字段默认值能否被正常处理
self.data2 = dict(id=2,
col_int=10, col_str="a", col_timestamp=time_now)
self.result2 = self.data2.copy()
self.result2.update(dict(
col_float=float_default_value,
col_bool=bool_default_value,
col_timestamp=timestamp,
col_int_null=None, col_str_null=None, col_float_null=None, col_bool_null=None, col_timestamp_null=None,
))
self.db.session.add(self.TestModel(**self.data1))
self.db.session.add(self.TestModel(**self.data2))
self.db.session.commit()
from flask import Flask,render_template,url_for,redirect,request,flash
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////Users/Lenovo/Desktop/TodoApp/todo.db'
db = SQLAlchemy(app)
app.secret_key="todo.py"
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80))
complete=db.Column(db.Boolean)
@app.route("/")
def index():
todos=Todo.query.all()
return render_template("index.html",todos=todos)
@app.route("/add",methods=["POST"])
def addTodo():
title=request.form.get("title")
newTodo=Todo(username=title,complete=0)
db.session.add(newTodo)
db.session.commit()
return redirect(url_for("index"))
@app.route("/complete/<string:id>")
def completeTodo(id):
todo=Todo.query.filter_by(id=id).first()
todo.complete= not todo.complete
db.session.commit()
from flask import Flask, request, abort, render_template, redirect, url_for, flash
from flask_script import Manager
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate, MigrateCommand
from werkzeug.security import generate_password_hash, check_password_hash
from flask_login import LoginManager, UserMixin, login_required, login_user, current_user, logout_user
from forms import ContactForm, LoginForm
app = Flask(__name__)
app.config.from_object(
os.environ.get('FLASK_ENV') or 'config.DevelopementConfig')
manager = Manager(app)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)
login_manager = LoginManager(app)
login_manager.login_view = 'login'
@app.route('/login/', methods=['post', 'get'])
def login():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = LoginForm()
if form.validate_on_submit():
user = db.session.query(User).filter(
User.username == form.username.data).first()
from flask_sqlalchemy import SQLAlchemy
DB = SQLAlchemy()
class Widget(DB.Model):
name = DB.Column(DB.String(100), primary_key=True)
fixed_costs = DB.Column(DB.Integer)
variable_costs = DB.Column(DB.Integer)
price_point = DB.Column(DB.Integer)
def __repr__(self):
return "{}".format(self.name)
products = [
# Name, fixed_costs, variable_costs, price_point
('Book', 5000.00, 4.50, 25.00),
('Truck', 10000000.00, 25000.00, 60000.00),
('Cup', 200.00, 0.50, 2.50),
('Burger', 25000.00, 3.50, 5.50),
]
def upload_widgets(widget_list):
for _ in range(len(widget_list)):
product = Widget(name=widget_list[_][0],
fixed_costs=widget_list[_][1],
variable_costs=widget_list[_][2],
price_point=widget_list[_][3])
DB.session.add(product)
class TriviaTestCase(unittest.TestCase):
"""This class represents the trivia test case"""
def setUp(self):
"""Define test variables and initialize app."""
self.app = create_app()
self.client = self.app.test_client
self.database_name = "trivia_test"
self.database_path = "postgres://{}/{}".format('localhost:5432', self.database_name)
setup_db(self.app, self.database_path)
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
# create all tables
self.db.create_all()
def tearDown(self):
"""Executed after reach test"""
pass
"""
TODO
Write at least one test for each test for successful operation and for expected errors.
"""
def test_get_categories(self):
res = self.client().get('/categories')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['categories'])
self.assertEqual(len(data['categories']), 6)
def test_get_questions(self):
res = self.client().get('/questions')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(len(data['questions']),10)
self.assertTrue(data['total_questions'])
self.assertEqual(len(data['categories']), 6)
def test_delete_questions(self):
res = self.client().delete('/questions/9')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def test_error_422_delete_questions(self):
res = self.client().delete('/questions/10000')
data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertEqual(data['success'], False)
def test_inserting_question(self):
res = self.client().post('/questions',json={'question': 'what is my name?', 'answer': 'Abdullah', 'difficulty': 3, 'category' : 3})
data = json.loads(res.data)
self.assertEqual(res.status_code, 201)
self.assertEqual(data['success'], True)
def test_error_422_inserting_question(self):
res = self.client().post('/questions',json={'question': '', 'answer': 'Abdullah', 'difficulty': 3, 'category' : 3})
data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertEqual(data['success'], False)
def test_search_question(self):
res = self.client().post('/questions/search',json={'searchTerm' : 'a'})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(len(data['questions']),10)
self.assertTrue(data['total_questions'])
self.assertEqual(len(data['categories']), 6)
def test_error_404_search_question(self):
res = self.client().post('/questions/search',json={'searchTerm' : 'abcdefghijk'})
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
def test_questions_by_category(self):
res = self.client().get('/categories/6/questions')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(len(data['questions']))
self.assertTrue(data['total_questions'])
self.assertEqual(data['current_category'], 'Sports')
def test_error_422_questions_by_category(self):
res = self.client().get('/categories/18746/questions')
data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertEqual(data['success'], False)
def test_play_the_quiz(self):
res = self.client().post('/quizzes',json={'previous_questions' : [4,18], 'quiz_category': {'type': 'Science', 'id':'1'}})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['question'])
def test_error_400_playing_the_quiz(self):
res = self.client().post('/quizzes',json={})
data = json.loads(res.data)
self.assertEqual(res.status_code, 400)
self.assertEqual(data['success'], False)
# TODO: Add configuration specifications so that email can be sent from this application, like the examples you saw in the textbook and in class. Make sure you've installed the correct library with pip! See textbook.
# NOTE: Make sure that you DO NOT write your actual email password in text!!!!
# NOTE: You will need to use a gmail account to follow the examples in the textbook, and you can create one of those for free, if you want. In THIS application, you should use the username and password from the environment variables, as directed in the textbook. So when WE run your app, we will be using OUR email, not yours.
app.config['MAIL_SERVER'] = 'smtp.googlemail.com'
app.config['MAIL_PORT'] = 587 #default
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = os.environ.get(
'MAIL_USERNAME'
) # TODO export to your environs -- may want a new account just for this. It's expecting gmail, not umich
app.config['MAIL_PASSWORD'] = os.environ.get('MAIL_PASSWORD')
app.config['MAIL_SUBJECT_PREFIX'] = '[Tweets App]'
app.config['MAIL_SENDER'] = '*****@*****.**' # TODO fill in email
app.config['ADMIN'] = os.environ.get('ADMIN')
# Set up Flask debug stuff
manager = Manager(app)
db = SQLAlchemy(app) # For database use
migrate = Migrate(app, db) # For database use/updating
manager.add_command('db', MigrateCommand) # Add migrate
mail = Mail(app)
# TODO: Run commands to create your migrations folder and get ready to create a first migration, as shown in the textbook and in class.
## Set up Shell context so it's easy to use the shell to debug
def make_shell_context():
return dict(app=app, db=db, Tweet=Tweet, User=User, Hashtag=Hashtag)
# Add function use to manager
manager.add_command("shell", Shell(make_context=make_shell_context))
def create_app():
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
db = SQLAlchemy(app)
class Kullanici(db.Model):
__tablename__ = 'Kullanici'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(80), unique=True)
sifre = db.Column(db.String(80))
rolId = db.Column(db.Integer,
db.ForeignKey('rol.rolId', ondelete='CASCADE'))
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
def __init__(self, email, sifre):
self.email = email
self.sifre = sifre
self.rolId = 0
class Roller(db.Model):
__tablename__ = 'rol'
rolId = db.Column(db.Integer, primary_key=True)
rolisim = db.Column(db.String(80))
class urunler(db.Model):
__tablename__ = 'urunler'
urun_id = db.Column(db.Integer, primary_key=True)
urunismi = db.Column(db.String(80))
urunresmi = db.Column(db.String(80))
urunFiyati = db.Column(db.Integer)
markaId = db.Column(
db.Integer(), db.ForeignKey('markalar.markaId',
ondelete='CASCADE'))
def __init__(self, urunismi, urunresmi, urunFiyati, markaId):
self.urunismi = urunismi
self.urunresmi = urunresmi
self.urunFiyati = urunFiyati
self.markaId = markaId
class markalar(db.Model):
__tablename__ = 'markalar'
markaId = db.Column(db.Integer, primary_key=True)
markaadi = db.Column(db.String(80))
marka_modeli = db.Column(db.String(80))
def __init__(self, markaadi, marka_modeli):
self.markaadi = markaadi
self.marka_modeli = marka_modeli
class musteri(db.Model):
__tablename__ = 'musteri'
musteriId = db.Column(db.Integer, primary_key=True)
musteriadi = db.Column(db.String(80))
musterisoyadi = db.Column(db.String(80))
mail = db.Column(db.String(80), unique=True)
telefon = db.Column(db.Integer)
sifre = db.Column(db.String(80))
il = db.Column(db.String(80))
ilce = db.Column(db.String(80))
kullaniciId = db.Column(
db.Integer(), db.ForeignKey('Kullanici.id', ondelete='CASCADE'))
def __init__(self, musteriadi, musterisoyadi, mail, telefon, sifre, il,
ilce, kullaniciId):
self.musteriadi = musteriadi
self.musterisoyadi = musterisoyadi
self.mail = mail
self.telefon = telefon
self.sifre = sifre
self.il = il
self.ilce = ilce
self.kullaniciId = kullaniciId
class siparis(db.Model):
__tablename__ = 'siparis'
siparisId = db.Column(db.Integer, primary_key=True)
musteriId = db.Column(
db.Integer(), db.ForeignKey('musteri.musteriId',
ondelete='CASCADE'))
urunId = db.Column(
db.Integer(), db.ForeignKey('urunler.urun_id', ondelete='CASCADE'))
siparisno = db.Column(db.Integer)
siparisTarihi = db.Column(db.Integer)
odemeId = db.Column(db.Integer())
def __init__(self, musteriId, urunId, siparisno, siparisTarihi,
odemeId):
self.musteriId = musteriId
self.urunId = urunId
self.siparisno = siparisno
self.siparisTarihi = siparisTarihi
self.odemeId = odemeId
db.create_all()
@app.route('/')
def anasayfa():
return render_template('index.html')
@app.route('/kayit', methods=['GET', 'POST'])
def kayit():
if request.method == 'POST':
mail = request.form['email']
parola = request.form['sifre']
yeniKullanici = Kullanici(email=mail, sifre=parola)
db.session.add(yeniKullanici)
db.session.commit()
if yeniKullanici is not None:
mesaj = "Kayıt Başarıyla Sağlanmıştır."
return render_template("index.html", mesaj=mesaj)
else:
return render_template('kayit.html')
@app.route('/admin')
def admin():
return render_template("admin.html")
@app.route('/uye', methods=['GET', 'POST'])
def uye():
return render_template("uyeGirisi.html")
@app.route('/giris', methods=['GET', 'POST'])
def giris():
hata = None
if request.method == 'POST':
if request.form['email'] != '*****@*****.**' or request.form[
'sifre'] != 'admin':
if Kullanici.query.filter_by(
email=request.form['email'],
sifre=request.form['sifre']) is not None:
session['uye_giris'] = True
return redirect(url_for('anasayfa'))
else:
hata = 'hatalı giris yaptınız'
else:
flash('giriş başarılı')
session['admin_giris'] = True
return redirect(url_for('admin'))
return render_template('uyeGiris.html', hata=hata)
@app.route('/cikis')
def cikis():
session.pop('admin_giris', None)
session.pop('uye_giris', None)
return render_template("index.html")
@app.route('/urunEkle')
def urunEkle():
tumVeri = urunler.query.all()
return render_template("urunEkle.html", tumVeri=tumVeri)
@app.route('/urunEklemeYap', methods=['POST'])
def urunEklemeYap():
urunismi = request.form['urunismi']
urunResmi = request.form['urunresmi']
urunFiyati = request.form['fiyati']
markaId = request.form['markaId']
yeniUrun = urunler(urunismi=urunismi,
urunresmi=urunResmi,
urunFiyati=urunFiyati,
markaId=markaId)
db.session.add(yeniUrun)
db.session.commit()
return redirect(url_for("urunEkle"))
@app.route("/sil/<string:id>")
def sil(id):
urun = urunler.query.filter_by(urun_id=id).first()
db.session.delete(urun)
db.session.commit()
return redirect(url_for("urunEkle"))
@app.route('/Markalar')
def markalar():
return
return app
from flask_sqlalchemy import SQLAlchemy
from flask import Flask, request, jsonify, url_for
db = SQLAlchemy()
fav_char = db.Table(
'fav_chars', db.metadata,
db.Column("user_id", db.Integer, db.ForeignKey("users.id")),
db.Column("char_id", db.Integer, db.ForeignKey("characters.id")))
fav_planet = db.Table(
'fav_planets', db.metadata,
db.Column("user_id", db.Integer, db.ForeignKey("users.id")),
db.Column("plan_id", db.Integer, db.ForeignKey("planets.id")))
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(250), nullable=False)
lastname = db.Column(db.String(250), nullable=False)
username = db.Column(db.String(250), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(80), unique=False, nullable=False)
is_active = db.Column(db.Boolean(),
unique=False,
nullable=False,
default=True)
characters = db.relationship("Character",
secondary=fav_char,
back_populates="users")
class TriviaTestCase(unittest.TestCase):
"""This class represents the trivia test case"""
def setUp(self):
"""Define test variables and initialize app."""
self.app = create_app()
self.client = self.app.test_client
self.database_name = 'trivia_test'
self.database_path = \
'postgres://*****:*****@{}/{}'.format(os.getenv('DATABASE_PASSWORD'
), 'localhost:5432', self.database_name)
setup_db(self.app, self.database_path)
self.new_question = {
'question': 'What is the best courses website',
'answer': 'Udacity',
'difficulty': 1,
'category': 1,
}
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
# create all tables
self.db.create_all()
def tearDown(self):
"""Executed after reach test"""
pass
def tearDown(self):
"""Executed after reach test"""
pass
def test_get_categories(self):
res = self.client().get('/categories')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['categories'])
def test_get_valid_page_questions(self):
res = self.client().get('/questions?page=1')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def test_404_sent_requesting_beyond_valid_page_questions(self):
res = self.client().get('/questions?page=1000')
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'Not found')
def test_search(self):
x = '{"searchTerm":"title"}'
res = self.client().post('/questions/search', json=json.loads(x))
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def test_questions_by_category(self):
res = self.client().get('/category/1/questions')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def test_404_questions_by_category_failue(self):
res = self.client().get('/category/100/questions')
data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'unprocessable')
def test_delete_question(self):
res = self.client().delete('/question/2')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def test_404_delete_question_failure(self):
res = self.client().delete('/question/200')
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'Not found')
def taking_quiz(self):
x = \
'{"previous_questions": [], "quiz_category": {"type": "click", "id": 0}}'
res = self.client().post('/quizzes', json=json.loads(x))
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def test_404_taking_quiz_failure(self):
res = self.client().post('/quizzes')
data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'unprocessable')
def test_create_question(self):
res = self.client().post('/questions', json=self.new_question)
data = json.loads(res.data)
pass
def test_422_if_question_creation_fails(self):
res = self.client().post('/questions', json=self.new_question)
data = json.loads(res.data)
pass
class TriviaTestCase(unittest.TestCase):
"""This class represents the trivia test case"""
def setUp(self):
"""Define test variables and initialize app."""
self.app = create_app()
self.client = self.app.test_client
self.database_name = "trivia1"
self.database_path = "postgres://{}/{}".format('postgres:P01019056637p@localhost:5432', self.database_name)
setup_db(self.app, self.database_path)
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
# create all tables
self.db.create_all()
def tearDown(self):
"""Executed after reach test"""
pass
"""
TODO
Write at least one test for each test for successful operation and for expected errors.
"""
def test_get_all_categories(self):
res = self.client().get('/categories')
json_data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(json_data['success'], True)
self.assertTrue(len(json_data['categories']))
self.assertTrue(json_data['total_categories'])
def test_get_paginated_questions(self):
res = self.client().get('/questions')
json_data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(json_data['success'], True)
self.assertTrue(len(json_data['questions']))
self.assertTrue(json_data['total_questions'])
self.assertTrue(len(json_data['categories']))
self.assertTrue(json_data['total_categories'])
def test_error_404_on_paginated_questions(self):
res = self.client().get('/questions?page=1000')
json_data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(json_data['success'], False)
self.assertEqual(json_data['error'], 404)
self.assertEqual(json_data['message'], 'resource not found')
def test_delete_question(self):
question = Question(question='question', answer='answer', category=1, difficulty=1)
question.insert()
question_id = question.id
res = self.client().delete('/questions/' + str(question.id))
json_data = json.loads(res.data)
question = Question.query.filter(Question.id == question.id).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(json_data['success'], True)
self.assertEqual(json_data['deleted_id'], question_id)
self.assertTrue(len(json_data['questions']))
self.assertTrue(json_data['total_questions'])
self.assertEqual(question, None)
def test_error_422_if_question_does_not_exist(self):
res = self.client().delete('/questions/100000')
json_data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertEqual(json_data['success'], False)
self.assertEqual(json_data['error'], 422)
self.assertEqual(json_data['message'], 'unprocessable')
def test_post_question(self):
question_fields = {
'question': 'question1',
'answer': 'answer1',
'category': 1,
'difficulty': 1,
}
res = self.client().post('/questions', json=question_fields)
json_data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(json_data['success'], True)
self.assertTrue(json_data['created_question'])
self.assertTrue(len(json_data['questions']))
self.assertTrue(json_data['total_questions'])
def test_422_error_in_post_questions(self):
question_fields = {
'question': '',
'answer': '',
# missing the 'category' field!
'difficulty': 1,
}
res = self.client().post('/questions', json=question_fields)
json_data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertEqual(json_data['success'], False)
self.assertEqual(json_data['error'], 422)
self.assertEqual(json_data['message'], 'unprocessable')
def test_search_in_questions(self):
res = self.client().post('/questions', json={'searchTerm': 'question1'})
json_data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(json_data['success'], True)
self.assertTrue(len(json_data['questions']))
self.assertTrue(json_data['total_questions'])
def test_with_wrong_value_for_searchTerm(self):
res = self.client().post('/questions', json={'searchTerm': 'asdaasdasdfasdasdasdfasfassd'})
json_data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(json_data['success'], False)
self.assertEqual(json_data['error'], 404)
self.assertEqual(json_data['message'], 'resource not found')
def test_get_questions_based_on_category(self):
category_id = 1
res = self.client().get('/categories/' + str(category_id) + '/questions')
json_data = json.loads(res.data)
category = Category.query.filter(Category.id == category_id).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(json_data['success'], True)
self.assertEqual(json_data['current_category'], category.type)
self.assertTrue(len(json_data['questions']))
self.assertTrue(json_data['total_questions'])
def test_404_in_get_questions_based_on_category(self):
category_id = 100000
res = self.client().get('/categories/' + str(category_id) + '/questions')
json_data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(json_data['success'], False)
self.assertEqual(json_data['error'], 404)
self.assertEqual(json_data['message'], 'resource not found')
def test_post_quizzes(self):
requested_data = {
'quiz_category': {
'id': 5,
'type': 'Entertainment'
}, 'previous_questions': [10, 11]
}
res = self.client().post('/quizzes', json=requested_data)
json_data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(json_data['success'], True)
self.assertTrue(len(json_data['question']))
def test_400_in_post_quizzes(self):
requested_data = {
'quiz_category': {
'id': 15,
'type': 'category1'
}
}
res = self.client().post('/quizzes', json=requested_data)
json_data = json.loads(res.data)
self.assertEqual(res.status_code, 400)
self.assertEqual(json_data['success'], False)
self.assertEqual(json_data['error'], 400)
self.assertEqual(json_data['message'], 'bad request')
def test_422_in_post_quizzes(self):
requested_data = {
'quiz_category': {
'id': 15,
'type': '5'
}, 'previous_questions': [10, 11]
}
res = self.client().post('/quizzes', json=requested_data)
json_data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertEqual(json_data['success'], False)
self.assertEqual(json_data['error'], 422)
self.assertEqual(json_data['message'], 'unprocessable')
from flask import Flask, flash, redirect, render_template, request, session, \
url_for, g
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.exc import IntegrityError
from datetime import datetime
# Config
app = Flask(__name__)
app.config.from_object('_config') #neat, I should probably look at docs for this
db = SQLAlchemy(app)
# Import custom dependencies
from forms import AddTaskForm, RegistrationForm, LoginForm
from models import Task, Account
from helpers.controller import login_required, flash_errors
from helpers.queries import open_tasks, closed_tasks
# Route handlers
@app.route('/', methods=['GET', 'POST'])
def login():
error = None
form = LoginForm(request.form)
if request.method == 'POST':
if form.validate_on_submit():
account = Account.query.filter_by(name=form.name.data).first()
if account is not None and account.password == form.password.data:
session['logged_in'] = True
session['account_id'] = account.id
flash('Welcome!')
return redirect(url_for('tasks'))
from flask import Flask, render_template, request, url_for
from flask_sqlalchemy import SQLAlchemy
import os
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret'
app.config['SQLALCHEMY_DATABASE_URL'] = os.environ.get("DATABASE_URL")
db = SQLAlchemy(app)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, primary_key=True)
email = db.Column(db.String, primary_key=True)
db.init_app()
@app.route("/new", method=['get', 'post'])
def new():
if request.method == 'POST':
email = request.form['email']
name = request.form['name']
user = User(name=name, email=email)
db.session.add(user)
manager = Manager(app)
#Setup SQLDatabase name
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///items.db'
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app.config['SECRET_KEY'] = 'hard to guess string'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
#Configure Login Settings
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'login'
login_manager.init_app(app)
#Initialize the database
db = SQLAlchemy(app)
#Naming convention to enable batch migrations
naming_convention = {
"ix": 'ix_%(column_0_label)s',
"uq": "uq_%(table_name)s_%(column_0_name)s",
"ck": "ck_%(table_name)s_%(column_0_name)s",
"fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
"pk": "pk_%(table_name)s"
}
db = SQLAlchemy(metadata=MetaData(naming_convention=naming_convention))
#Add migration to database
migrate = Migrate(app, db, render_as_batch=True)
manager.add_command("db", MigrateCommand)
from app.utils.log import FinalLogger
import sys
reload(sys)
sys.setdefaultencoding("utf-8")
# mail = Mail()
#设置db.session.query 可以使用分页类
session_options = {}
session_options['query_cls'] = BaseQuery
session_options['autocommit'] = False
session_options['autoflush'] = False
session_options['expire_on_commit'] = False
db = SQLAlchemy(session_options=session_options)
login_manager = LoginManager()
login_manager.session_protection = 'basic'
login_manager.login_view = 'admin.login'
login_manager.login_message = None
VERSION = '1.0.0'
def register_blueprints(app):
#注册蓝图
from .controller.admin import admin
app.register_blueprint(admin)
def create_app(config_name):
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
db = SQLAlchemy()
def init_db(app):
app.app_context().push()
db.init_app(app)
db.create_all()
task_tag_table = db.Table('task_tag_table',
db.Column('task_id', db.Integer, db.ForeignKey('task.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'))
)
class Task(db.Model):
id = db.Column(db.Integer, nullable=False, primary_key=True)
task_title = db.Column(db.String(50), nullable=False)
task_content = db.Column(db.String(500), nullable=False)
date_start = db.Column(db.DateTime, default=datetime.utcnow)
date_end = db.Column(db.DateTime)
tags = db.relationship("Tag", secondary=task_tag_table, backref=db.backref('tags_associated', lazy='joined'))
class Tag(db.Model):
id = db.Column(db.Integer, nullable=False, primary_key=True)
tag_title = db.Column(db.String(50), nullable=False)
tag_desc = db.Column(db.String(500))
from flask_migrate import Migrate
from dash import Dash
from dash.dependencies import Input, State, Output
import dash_core_components as dcc
import dash_html_components as html
from elasticsearch import Elasticsearch
from flask_babel import Babel, lazy_gettext as _l
import json
import plotly
import pandas as pd
import numpy as np
AppServer = Flask(__name__)
AppServer.config.from_object(Config)
db = SQLAlchemy(AppServer)
babel = Babel()
babel.init_app(AppServer)
db.init_app(AppServer)
AppServer.elasticsearch = Elasticsearch([AppServer.config['ELASTICSEARCH_URL']]) \
if AppServer.config['ELASTICSEARCH_URL'] else None
migrate = Migrate(AppServer, db)
from app import routes, models
#@AppServer.route('/', methods=['GET', 'POST'])
#@AppServer.route('/index', methods=['GET', 'POST'])
#def index():
#return render_template('visualization.html')
# Set up email config stuff
app.config['MAIL_SERVER'] = 'smtp.googlemail.com'
app.config['MAIL_PORT'] = 587 #default
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = os.environ.get('MAIL_USERNAME') # TODO export to your environs -- may want a new account just for this. It's expecting gmail, not umich
app.config['MAIL_PASSWORD'] = os.environ.get('MAIL_PASSWORD')
app.config['MAIL_SUBJECT_PREFIX'] = '[Songs App]'
app.config['MAIL_SENDER'] = 'Admin <*****@*****.**>' # TODO fill in email
app.config['ADMIN'] = os.environ.get('ADMIN') or "Admin <*****@*****.**>"
app.config['HEROKU_ON'] = os.environ.get('HEROKU') #1
# Set up Flask debug stuff
manager = Manager(app)
# moment = Moment(app) # For time # Later
db = SQLAlchemy(app) # For database use
migrate = Migrate(app, db) # For database use/updating
manager.add_command('db', MigrateCommand) # Add migrate command to manager
mail = Mail(app) # For email sending
## Set up Shell context so it's easy to use the shell to debug
# Define function
def make_shell_context():
return dict( app=app, db=db, Song=Song, Artist=Artist, Album=Album)
# Add function use to manager
manager.add_command("shell", Shell(make_context=make_shell_context))
## You will get the following message when running command to create migration folder:
## python main_app.py db init
## -->
# Logging
log = logging.getLogger('werkzeug')
log.setLevel(logging.ERROR)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler = logging.StreamHandler()
handler.setFormatter(formatter)
app.logger.setLevel(app.config.get('LOG_LEVEL', "INFO"))
app.logger.addHandler(handler)
# swagger
api = swagger.docs(Api(app), apiVersion=SpiderKeeper.__version__, api_spec_url="/api",
description='SpiderKeeper')
# Define the database object which is imported
# by modules and controllers
db = SQLAlchemy(app, session_options=dict(autocommit=False, autoflush=True))
@app.teardown_request
def teardown_request(exception):
if exception:
db.session.rollback()
db.session.remove()
db.session.remove()
# Define apscheduler
scheduler = BackgroundScheduler()
class Base(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
def generate_app(db_uri=None,
db_options=None,
upload_folder=None,
secret_key=None,
allowed_extensions=None,
ll=None, vl=None, pl=None, flask_configs=None,
disable_admin_check=False):
app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = upload_folder
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
if flask_configs:
for k, v in flask_configs.items():
app.config[k] = v
app.secret_key = secret_key
# ALLOWED_EXTENSIONS = set(ext for ext in re.split('[\s,]+',
# allowed_extensions)
# if ext is not None and ext != '')
login_manager = LoginManager()
login_manager.init_app(app)
app.login_manager = login_manager
login_manager.login_view = 'login'
bcrypt = Bcrypt(app)
app.bcrypt = bcrypt
if pl is None:
app.config['SQLALCHEMY_DATABASE_URI'] = db_uri
opts = split_db_options(db_options)
app.config['SQLALCHEMY_ENGINE_OPTIONS'] = opts
db = SQLAlchemy(app)
pl = SqlAlchemyPersistenceLayer(db)
app.pl = pl
class Options(object):
@staticmethod
def get(key, default_value=None):
option = pl.get_option(key)
if option is None:
return default_value
return option.value
@staticmethod
def get_title():
return Options.get('title', 'Tudor')
@staticmethod
def get_revision():
return __revision__
@staticmethod
def get_version():
return __version__
@staticmethod
def get_author():
return Options.get('author', 'the author')
@staticmethod
def get_user():
if current_user is None:
return pl.get_guest_user()
try:
user_id = current_user.id
return pl.get_user(user_id)
except AttributeError:
return pl.get_guest_user()
app.Options = Options
if ll is None:
ll = LogicLayer(upload_folder, allowed_extensions, pl)
app.ll = ll
if vl is None:
vl = ViewLayer(ll, app.bcrypt)
app.vl = vl
# Flask setup functions
@login_manager.user_loader
def load_user(userid):
return pl.get_user_by_email(userid)
@login_manager.request_loader
def load_user_with_basic_auth(request):
api_key = request.headers.get('Authorization')
if api_key:
api_key = api_key.replace('Basic ', '', 1)
api_key = base64.b64decode(api_key).decode('utf-8')
email, password = api_key.split(':', 1)
user = pl.get_user_by_email(email)
if user is None:
return None
if user.hashed_password is None or user.hashed_password == '':
return None
if not bcrypt.check_password_hash(user.hashed_password, password):
return None
return user
def admin_required(func):
@wraps(func)
def decorated_view(*args, **kwargs):
if not disable_admin_check and not current_user.is_admin:
return ('You are not authorized to view this page', 403)
return func(*args, **kwargs)
return decorated_view
@app.context_processor
def setup_options():
return {'opts': Options}
# View Functions
@app.route('/')
@login_required
def index():
return vl.index(request, Options.get_user())
@app.route('/hierarchy')
@login_required
def hierarchy():
return vl.hierarchy(request, Options.get_user())
@app.route('/deadlines')
@login_required
def deadlines():
return vl.deadlines(request, Options.get_user())
@app.route('/task/new', methods=['GET'])
@login_required
def get_new_task():
return vl.task_new_get(request, Options.get_user())
@app.route('/task/new', methods=['POST'])
@login_required
def new_task():
return vl.task_new_post(request, Options.get_user())
@app.route('/task/<int:id>/mark_done')
@login_required
def task_done(id):
return vl.task_mark_done(request, Options.get_user(), id)
@app.route('/task/<int:id>/mark_undone')
@login_required
def task_undo(id):
return vl.task_mark_undone(request, Options.get_user(), id)
@app.route('/task/<int:id>/delete')
@login_required
def delete_task(id):
return vl.task_delete(request, Options.get_user(), id)
@app.route('/task/<int:id>/undelete')
@login_required
def undelete_task(id):
return vl.task_undelete(request, Options.get_user(), id)
@app.route('/task/<int:id>/purge')
@login_required
@admin_required
def purge_task(id):
return vl.task_purge(request, Options.get_user(), id)
@app.route('/purge_all')
@login_required
@admin_required
def purge_deleted_tasks():
return vl.purge_all(request, Options.get_user())
@app.route('/task/<int:id>')
def view_task(id):
return vl.task(request, Options.get_user(), id)
@app.route('/task/<int:id>/hierarchy')
def view_task_hierarchy(id):
return vl.task_hierarchy(request, Options.get_user(), id)
@app.route('/note/new', methods=['POST'])
@login_required
def new_note():
return vl.note_new_post(request, Options.get_user())
@app.route('/task/<int:id>/edit', methods=['GET', 'POST'])
@login_required
def edit_task(id):
return vl.task_edit(request, Options.get_user(), id)
@app.route('/attachment/new', methods=['POST'])
@login_required
def new_attachment():
return vl.attachment_new(request, Options.get_user(),
timestamp=datetime.utcnow())
@app.route('/attachment/<int:aid>', defaults={'x': 'x'})
@app.route('/attachment/<int:aid>/', defaults={'x': 'x'})
@app.route('/attachment/<int:aid>/<path:x>')
@login_required
def get_attachment(aid, x):
return vl.attachment(request, Options.get_user(), aid, x)
@app.route('/task/<int:id>/up')
@login_required
def move_task_up(id):
return vl.task_up(request, Options.get_user(), id)
@app.route('/task/<int:id>/top')
@login_required
def move_task_to_top(id):
return vl.task_top(request, Options.get_user(), id)
@app.route('/task/<int:id>/down')
@login_required
def move_task_down(id):
return vl.task_down(request, Options.get_user(), id)
@app.route('/task/<int:id>/bottom')
@login_required
def move_task_to_bottom(id):
return vl.task_bottom(request, Options.get_user(), id)
@app.route('/long_order_change', methods=['POST'])
@login_required
def long_order_change():
return vl.long_order_change(request, Options.get_user())
@app.route('/task/<int:id>/add_tag', methods=['GET', 'POST'])
@login_required
def add_tag_to_task(id):
return vl.task_add_tag(request, Options.get_user(), id)
@app.route('/task/<int:id>/delete_tag', methods=['GET', 'POST'],
defaults={'tag_id': None})
@app.route('/task/<int:id>/delete_tag/', methods=['GET', 'POST'],
defaults={'tag_id': None})
@app.route('/task/<int:id>/delete_tag/<tag_id>', methods=['GET', 'POST'])
@login_required
def delete_tag_from_task(id, tag_id):
return vl.task_delete_tag(request, Options.get_user(), id, tag_id)
@app.route('/task/<int:task_id>/authorize_user', methods=['GET', 'POST'])
@login_required
def authorize_user_for_task(task_id):
return vl.task_authorize_user(request, Options.get_user(), task_id)
@app.route('/task/<int:task_id>/pick_user')
@login_required
def pick_user_to_authorize(task_id):
return vl.task_pick_user(request, Options.get_user(), task_id)
@app.route('/task/<int:task_id>/authorize_user/<int:user_id>',
methods=['GET', 'POST'])
@login_required
def authorize_picked_user_for_task(task_id, user_id):
return vl.task_authorize_user_user(request, Options.get_user(),
task_id, user_id)
@app.route('/task/<int:task_id>/deauthorize_user', methods=['GET', 'POST'],
defaults={'user_id': None})
@app.route('/task/<int:task_id>/deauthorize_user/',
methods=['GET', 'POST'], defaults={'user_id': None})
@app.route('/task/<int:task_id>/deauthorize_user/<int:user_id>',
methods=['GET', 'POST'])
@login_required
def deauthorize_user_for_task(task_id, user_id):
return vl.task_deauthorize_user(request, Options.get_user(), task_id,
user_id)
@app.route('/login', methods=['GET', 'POST'])
def login():
return vl.login(request, Options.get_user())
@app.route('/logout')
def logout():
return vl.logout(request, Options.get_user())
@app.route('/users', methods=['GET', 'POST'])
@login_required
@admin_required
def list_users():
return vl.users(request, Options.get_user())
@app.route('/users/<int:user_id>', methods=['GET'])
@login_required
def view_user(user_id):
return vl.users_user_get(request, Options.get_user(), user_id)
@app.route('/show_hide_deleted')
@login_required
def show_hide_deleted():
return vl.show_hide_deleted(request, Options.get_user())
@app.route('/show_hide_done')
@login_required
def show_hide_done():
return vl.show_hide_done(request, Options.get_user())
@app.route('/options', methods=['GET', 'POST'])
@login_required
@admin_required
def view_options():
return vl.options(request, Options.get_user())
@app.route('/option/<path:key>/delete')
@login_required
@admin_required
def delete_option(key):
return vl.option_delete(request, Options.get_user(), key)
@app.route('/reset_order_nums')
@login_required
def reset_order_nums():
return vl.reset_order_nums(request, Options.get_user())
@app.route('/export', methods=['GET', 'POST'])
@login_required
@admin_required
def export_data():
return vl.export(request, Options.get_user())
@app.route('/import', methods=['GET', 'POST'])
@login_required
@admin_required
def import_data():
return vl.import_(request, Options.get_user())
@app.route('/task_crud', methods=['GET', 'POST'])
@login_required
@admin_required
def task_crud():
return vl.task_crud(request, Options.get_user())
@app.route('/tags')
@app.route('/tags/')
@login_required
def list_tags():
return vl.tags(request, Options.get_user())
@app.route('/tags/<int:id>')
@login_required
def view_tag(id):
return vl.tags_id_get(request, Options.get_user(), id)
@app.route('/tags/<int:id>/edit', methods=['GET', 'POST'])
@login_required
def edit_tag(id):
return vl.tags_id_edit(request, Options.get_user(), id)
@app.route('/task/<int:id>/convert_to_tag')
@login_required
def convert_task_to_tag(id):
return vl.task_id_convert_to_tag(request, Options.get_user(), id)
@app.route('/search', methods=['GET', 'POST'],
defaults={'search_query': None})
@app.route('/search/', methods=['GET', 'POST'],
defaults={'search_query': None})
@app.route('/search/<search_query>', methods=['GET'])
@login_required
def search(search_query):
return vl.search(request, Options.get_user(), search_query)
@app.route('/task/<int:task_id>/add_dependee', methods=['GET', 'POST'],
defaults={'dependee_id': None})
@app.route('/task/<int:task_id>/add_dependee/', methods=['GET', 'POST'],
defaults={'dependee_id': None})
@app.route('/task/<int:task_id>/add_dependee/<int:dependee_id>',
methods=['GET', 'POST'])
@login_required
def add_dependee_to_task(task_id, dependee_id):
return vl.task_id_add_dependee(request, Options.get_user(), task_id,
dependee_id)
@app.route('/task/<int:task_id>/remove_dependee',
methods=['GET', 'POST'], defaults={'dependee_id': None})
@app.route('/task/<int:task_id>/remove_dependee/',
methods=['GET', 'POST'], defaults={'dependee_id': None})
@app.route('/task/<int:task_id>/remove_dependee/<int:dependee_id>',
methods=['GET', 'POST'])
@login_required
def remove_dependee_from_task(task_id, dependee_id):
return vl.task_id_remove_dependee(request, Options.get_user(), task_id,
dependee_id)
@app.route('/task/<int:task_id>/add_dependant', methods=['GET', 'POST'],
defaults={'dependant_id': None})
@app.route('/task/<int:task_id>/add_dependant/', methods=['GET', 'POST'],
defaults={'dependant_id': None})
@app.route('/task/<int:task_id>/add_dependant/<int:dependant_id>',
methods=['GET', 'POST'])
@login_required
def add_dependant_to_task(task_id, dependant_id):
return vl.task_id_add_dependant(request, Options.get_user(), task_id,
dependant_id)
@app.route('/task/<int:task_id>/remove_dependant',
methods=['GET', 'POST'], defaults={'dependant_id': None})
@app.route('/task/<int:task_id>/remove_dependant/',
methods=['GET', 'POST'], defaults={'dependant_id': None})
@app.route('/task/<int:task_id>/remove_dependant/<int:dependant_id>',
methods=['GET', 'POST'])
@login_required
def remove_dependant_from_task(task_id, dependant_id):
return vl.task_id_remove_dependant(request, Options.get_user(),
task_id, dependant_id)
@app.route('/task/<int:task_id>/add_prioritize_before',
methods=['GET', 'POST'],
defaults={'prioritize_before_id': None})
@app.route('/task/<int:task_id>/add_prioritize_before/',
methods=['GET', 'POST'],
defaults={'prioritize_before_id': None})
@app.route(
'/task/<int:task_id>/add_prioritize_before/<int:prioritize_before_id>',
methods=['GET', 'POST'])
@login_required
def add_prioritize_before_to_task(task_id, prioritize_before_id):
return vl.task_id_add_prioritize_before(request, Options.get_user(),
task_id, prioritize_before_id)
@app.route('/task/<int:task_id>/remove_prioritize_before',
methods=['GET', 'POST'],
defaults={'prioritize_before_id': None})
@app.route('/task/<int:task_id>/remove_prioritize_before/',
methods=['GET', 'POST'],
defaults={'prioritize_before_id': None})
@app.route(
'/task/<int:task_id>/remove_prioritize_before/'
'<int:prioritize_before_id>',
methods=['GET', 'POST'])
@login_required
def remove_prioritize_before_from_task(task_id, prioritize_before_id):
return vl.task_id_remove_prioritize_before(request, Options.get_user(),
task_id,
prioritize_before_id)
@app.route('/task/<int:task_id>/add_prioritize_after',
methods=['GET', 'POST'], defaults={'prioritize_after_id': None})
@app.route('/task/<int:task_id>/add_prioritize_after/',
methods=['GET', 'POST'], defaults={'prioritize_after_id': None})
@app.route(
'/task/<int:task_id>/add_prioritize_after/<int:prioritize_after_id>',
methods=['GET', 'POST'])
@login_required
def add_prioritize_after_to_task(task_id, prioritize_after_id):
return vl.task_id_add_prioritize_after(request, Options.get_user(),
task_id, prioritize_after_id)
@app.route('/task/<int:task_id>/remove_prioritize_after',
methods=['GET', 'POST'], defaults={'prioritize_after_id': None})
@app.route('/task/<int:task_id>/remove_prioritize_after/',
methods=['GET', 'POST'], defaults={'prioritize_after_id': None})
@app.route(
'/task/<int:task_id>/remove_prioritize_after/'
'<int:prioritize_after_id>',
methods=['GET', 'POST'])
@login_required
def remove_prioritize_after_from_task(task_id, prioritize_after_id):
return vl.task_id_remove_prioritize_after(request, Options.get_user(),
task_id, prioritize_after_id)
@app.template_filter(name='gfm')
def render_gfm(s):
output = markdown.markdown(s, extensions=['gfm'])
moutput = Markup(output)
return moutput
return app
Created on Thu Oct 22 17:52:45 2020
@author: Nic
"""
from __future__ import absolute_import
from datetime import datetime
import os
import pytz
from flask import Flask, request, Response, jsonify, render_template
from flask_sqlalchemy import SQLAlchemy
from threading import Thread
app = Flask(__name__)
db = SQLAlchemy(app)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL']
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
app.config[
'JSONIFY_PRETTYPRINT_REGULAR'] = True # for prettyprinting in /getall
from plotlydash.dashboard import init_dashboard
app = init_dashboard(app, db)
from models import Record
from utilities import load_backup, add_data
try:
str_tz = os.environ[
"TZ"] #TODO: make this into an app.config['str_tz'] = ...
except:
str_tz = 'America/Los_Angeles'
from flask import Flask
app = Flask(__name__)
from flask_sqlalchemy import SQLAlchemy
import os
if os.environ.get("HEROKU"):
app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DATABASE_URL")
else:
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///staffitup.db"
app.config["SQLALCHEMY_ECHO"] = True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
from os import urandom
app.config["SECRET_KEY"] = urandom(32)
from flask_login import LoginManager, current_user
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "auth_login"
login_manager.login_message = "Ole hyvä ja kirjaudu sisään käyttääksesi tätä toimintoa"
from functools import wraps
def login_required(role="ANY"):
def wrapper(fn):
@wraps(fn)
#----------------------------------------------------------------------------#
# Imports
#----------------------------------------------------------------------------#
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from flask_moment import Moment
from app import app
#----------------------------------------------------------------------------#
# App Config.
#----------------------------------------------------------------------------#
moment = Moment(app)
app.config.from_object('config')
db = SQLAlchemy(app)
migrate = Migrate(app, db)
#----------------------------------------------------------------------------#
# Models.
#----------------------------------------------------------------------------#
# Genre database
class Genre(db.Model):
__tablename__ = 'Genre'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(), nullable=False)
slug = db.Column(db.String(), unique=True, nullable=False)
from flask_cors import CORS
from sqlalchemy.sql.expression import func
from flask_security import Security, SQLAlchemyUserDatastore, hash_password, login_required
from flask_security.models import fsqla_v2 as fsqla
from werkzeug.utils import secure_filename
app = Flask(__name__,
template_folder='templates',
static_folder='templates/search/build/static'
)
app.config['UPLOAD_FOLDER'] = '/tmp'
# Database setup
app.config.from_object('config.Config')
db = SQLAlchemy(app)
CORS(app)
# Security
fsqla.FsModels.set_db_info(db)
# Define models
class Role(db.Model, fsqla.FsRoleMixin):
pass
class User(db.Model, fsqla.FsUserMixin):
pass
app.use_reloader = True
app.config['SECRET_KEY'] = 'hard to guess string from si364'
## TODO 364: Create a database in postgresql in the code line below, and fill in your app's database URI. It should be of the format: postgresql://localhost/YOUR_DATABASE_NAME
## Your final Postgres database should be your uniqname, plus HW5, e.g. "jczettaHW5" or "maupandeHW5"
app.config["SQLALCHEMY_DATABASE_URI"] = "postgresql://*****:*****@localhost:5432/final"
## Provided:
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
##################
### App setup ####
##################
# App addition setups
manager = Manager(app)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)
# Login configurations setup
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'login'
login_manager.init_app(app) # set up login manager
#flickr setup
flickr = FlickrAPI(FLICKR_PUBLIC, FLICKR_SECRET, format='parsed-json')
extras='url_sq,url_t,url_s,url_q,url_m,url_n,url_z,url_c,url_l,url_o'
#########################
##### Set up Models #####
#########################
class CookeryMoodTestCase(unittest.TestCase):
"""This class represents the trivia test case"""
def setUp(self):
"""Define test variables and initialize app."""
self.app = create_app()
self.client = self.app.test_client
self.database_name = "easylist_test"
DB_USERNAME = "******"
DB_PASSWORD = "******"
self.database_path = "postgresql://{}:{}@{}/{}".format(
DB_USERNAME, DB_PASSWORD, 'localhost:5432', self.database_name)
setup_db(self.app, self.database_path)
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
# create all tables
self.db.create_all()
def tearDown(self):
"""Executed after reach test"""
pass
# GET /recipes
def test_get_paginated_recipes(self):
res = self.client().get('/recipes')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['recipes'])
def test_404_sent_reguesting_beyond_valid_page(self):
res = self.client().get('/recipes?page=2')
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'resource not found')
'''create recipe'''
# POST /recipes
'''Administrator'''
def test_create_recipe(self):
new_recipe = init_new_recipe()
res = self.client().post(
'/recipes',
headers={'Authorization': 'Bearer ' + str(ADMINISTRATOR_TOKEN)},
json=new_recipe)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['created'])
self.assertTrue(data['recipes'])
'''User'''
def test_401_if_create_recipe_unauthorized(self):
new_recipe = init_new_recipe()
res = self.client().post(
'/recipes',
headers={'Authorization': 'Bearer ' + str(USER_TOKEN)},
json=new_recipe)
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertEqual(data['code'], 'unauthorized')
self.assertEqual(data['description'], 'Permission not found.')
def test_422_if_recipe_creation_empty_data(self):
new_recipe = {
"name": "Potato salad",
"time_to_prepare": "10 min.",
"cooking_time": "10 min.",
"description": "{1: ‘step 1’ , 2: ‘step 2'}",
"item_list": []
}
res = self.client().post(
'/recipes',
headers={'Authorization': 'Bearer ' + str(ADMINISTRATOR_TOKEN)},
json=new_recipe)
data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'unprocessable')
'''Delete'''
'''Administrator'''
def test_delete_recipe(self):
new_recipe = init_new_recipe()
res_new = self.client().post(
'/recipes',
headers={'Authorization': 'Bearer ' + str(ADMINISTRATOR_TOKEN)},
json=new_recipe)
data_new = json.loads(res_new.data)
id_new = data_new['created']
res = self.client().delete(
'/recipes/{}'.format(id_new),
headers={'Authorization': 'Bearer ' + str(ADMINISTRATOR_TOKEN)})
data = json.loads(res.data)
recipe = Recipe.query.filter(Recipe.id == id_new).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(data['deleted'], str(id_new))
self.assertTrue(len(data['recipes']))
self.assertEqual(recipe, None)
'''user'''
def test_401_delete_recipe_unauthorized(self):
res = self.client().delete(
'/recipes/17',
headers={'Authorization': 'Bearer ' + str(USER_TOKEN)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertEqual(data['code'], 'unauthorized')
self.assertEqual(data['description'], 'Permission not found.')
# if recipe doesn't exist
def test_404_if_recipe_does_not_exist(self):
res = self.client().delete(
'/recipes/10000',
headers={'Authorization': 'Bearer ' + str(ADMINISTRATOR_TOKEN)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'resource not found')
# PATCH /recipes
'''Administrator'''
def test_update_recipe(self):
new_recipe = init_new_recipe()
res = self.client().patch(
'/recipes/5',
headers={'Authorization': 'Bearer ' + str(ADMINISTRATOR_TOKEN)},
json={"name": "Potato"})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['recipe_id'], "5")
def test_404_if_updated_recipe_does_not_exist(self):
res = self.client().patch(
'/recipes/10000',
headers={'Authorization': 'Bearer ' + str(ADMINISTRATOR_TOKEN)},
json={"name": "Potato"})
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'resource not found')
from flask import Flask # from config import Config from login.config import Config from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate from flask_login import LoginManager loginApp = Flask(__name__) loginApp.config.from_object(Config) loginDB = SQLAlchemy(loginApp) migrate = Migrate(loginApp, loginDB) login = LoginManager(loginApp) login.login_view = "login" # import routes from login import routes
## To Run
## export FLASK_APP=__init.py
## flask run
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy() # set database varaible
def create_app():
#Flask Config varaibles
app = Flask(__name__)
app.config['ENV'] = 'development'
app.config['DEBUG'] = True
app.config['TESTING'] = True
# Initilise database
db.init_app(app)
# Import Blueprints
from .api.routes import api
from .site.routes import site
app.register_blueprint(api, url_prefix='/api')
app.register_blueprint(site)
return app
if __name__ == "__main__":
create_app().run()
class CastingAgencyTestCase(unittest.TestCase):
"""This class represents the casting agency test case"""
def setUp(self):
"""Define test variables and initialize app."""
self.app = create_app()
self.client = self.app.test_client
self.database_path = os.environ['TEST_DATABASE_URL']
setup_db(self.app, self.database_path)
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
# drop and create all tables
db_drop_and_create_all()
# sample actor to be used for test
self.new_actor_1 = {
'name': 'Gal Gadot',
'gender': 'female',
'age': 35,
}
self.new_actor_2 = {
'name': 'Daisy Ridley',
'gender': 'female',
'age': 30,
}
self.update_actor = {
'name': 'Daisy Ridley',
'gender': 'female',
'age': 28,
}
self.new_movie_1 = {
'title': 'Mission: Impossible 7',
'release_date': '2021-11-19',
}
self.new_movie_2 = {
'title': 'Matrix',
'release_date': '2021-12-22',
}
self.update_movie = {
'title': 'The Matrix 4',
'release_date': '2021-12-22',
}
def tearDown(self):
"""Executed after reach test"""
pass
"""
TODO
Write at least one test for each test for successful operation
and for expected errors.
"""
"""
Test API endpoint for actors
"""
def test_post_actors(self):
res = self.client().post(
'/actors',
json=self.new_actor_1,
headers={"Authorization": (casting_director_jwt)})
data = json.loads(res.data)
# check status and status message
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['actor'])
def test_get_actors(self):
res = self.client().get(
'/actors', headers={"Authorization": (casting_assistant_jwt)})
data = json.loads(res.data)
# check status and status message
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(len(data['actors']) >= 0)
def test_patch_actors(self):
res = self.client().post(
'/actors',
json=self.new_actor_1,
headers={"Authorization": (executive_producer_jwt)})
res = self.client().patch(
'/actors/1',
json=self.update_actor,
headers={"Authorization": (executive_producer_jwt)})
data = json.loads(res.data)
# check status and status message
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(len(data['actor']) == 1)
def test_delete_actors(self):
res = self.client().post(
'/actors',
json=self.new_actor_1,
headers={"Authorization": (executive_producer_jwt)})
res = self.client().post(
'/actors',
json=self.new_actor_2,
headers={"Authorization": (executive_producer_jwt)})
res = self.client().delete(
'/actors/2', headers={"Authorization": (executive_producer_jwt)})
data = json.loads(res.data)
# check status and status message
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['delete'] == 2)
"""
Test API endpoint for movies
"""
def test_post_movies(self):
res = self.client().post(
'/movies',
json=self.new_movie_1,
headers={"Authorization": (executive_producer_jwt)})
data = json.loads(res.data)
# check status and status message
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['movie'])
def test_get_movies(self):
res = self.client().get(
'/movies', headers={"Authorization": (casting_assistant_jwt)})
data = json.loads(res.data)
# check status and status message
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(len(data['movies']) >= 0)
def test_patch_movies(self):
res = self.client().post(
'/movies',
json=self.new_movie_2,
headers={"Authorization": (executive_producer_jwt)})
res = self.client().patch(
'/movies/1',
json=self.update_movie,
headers={"Authorization": (executive_producer_jwt)})
data = json.loads(res.data)
# check status and status message
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(len(data['movie']) == 1)
def test_delete_movies(self):
res = self.client().post(
'/movies',
json=self.new_movie_1,
headers={"Authorization": (executive_producer_jwt)})
res = self.client().post(
'/movies',
json=self.new_movie_2,
headers={"Authorization": (executive_producer_jwt)})
res = self.client().delete(
'/movies/2', headers={"Authorization": (executive_producer_jwt)})
data = json.loads(res.data)
# check status and status message
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['delete'] == 2)
"""
Test Error behaviour for /actors
"""
# Test non-existent actor
def test_404_get_request_non_existent_actor(self):
res = self.client().get(
'/actors/1000',
headers={"Authorization": (executive_producer_jwt)})
data = json.loads(res.data)
# check status and status message
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'resource not found')
# Test non-existent actor update
def test_404_update_actors(self):
res = self.client().patch(
'/actors/1000',
json=self.update_actor,
headers={"Authorization": (executive_producer_jwt)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertFalse(data['success'])
self.assertEqual(data['message'], 'resource not found')
# Test non-existent actor deletion
def test_404_delete_request_non_existent_actor(self):
res = self.client().delete(
'/actors/1599',
headers={"Authorization": (executive_producer_jwt)})
data = json.loads(res.data)
# check status and status message
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'resource not found')
# Test get actor without RBAC permission
def test_401_get_actors(self):
res = self.client().get('/actors')
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertFalse(data['success'])
# Test actor creation without RBAC permission
def test_401_post_actors(self):
res = self.client().post('/actors', json=self.new_actor_2)
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertFalse(data['success'])
"""
Test Error behaviour for /movies
"""
# Test non-existent movie
def test_404_get_request_non_existent_movie(self):
res = self.client().get(
'/movies/1000',
headers={"Authorization": (executive_producer_jwt)})
data = json.loads(res.data)
# check status and status message
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'resource not found')
# Test non-existent movie update
def test_404_patch_movies(self):
res = self.client().patch(
'/movies/1500',
json=self.update_movie,
headers={"Authorization": (executive_producer_jwt)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertFalse(data['success'])
self.assertEqual(data['message'], 'resource not found')
# Test non-existent movie deletion
def test_404_delete_request_non_existent_movie(self):
res = self.client().delete(
'/movies/1500',
headers={"Authorization": (executive_producer_jwt)})
data = json.loads(res.data)
# check status and status message
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'resource not found')
# Test get actor without RBAC permission
def test_401_get_movies(self):
res = self.client().get('/movies')
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertFalse(data['success'])
# Test movie creation without RBAC permission
def test_401_post_movies(self):
res = self.client().post('/movies', json=self.new_movie_2)
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertFalse(data['success'])
def get_db():
if 'db' not in g:
g.db = connect_to_database()
return g.db
app = create_app()
if dev:
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///reeats.db'
else:
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgres://*****:*****@ec2-54-165-36-134.compute-1.amazonaws.com:5432/d4pdqjkun0inr5'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db_sql = SQLAlchemy(app)
# -----------------------------------------------------------------------
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'
app.config['TESTING'] = False
app.config.update(dict(
DEBUG = True,
MAIL_SERVER = 'smtp.gmail.com',
MAIL_PORT = 587,
MAIL_USE_TLS = True,
MAIL_USE_SSL = False,
MAIL_USERNAME = '******',
MAIL_PASSWORD = '******',
from flask_sqlalchemy import SQLAlchemy
from flask_bootstrap import Bootstrap
from flask_login import LoginManager
from flask_mail import Mail
from flask_moment import Moment
from flask_whooshee import Whooshee
from flask_wtf import CSRFProtect
db=SQLAlchemy()
bootstrap=Bootstrap()
login_manager=LoginManager()
mail=Mail()
moment=Moment()
whooshee=Whooshee()
csrf = CSRFProtect()
@login_manager.user_loader
def load_user(user_id):
from tt.models import User
return User.query.get(int(user_id))
from re import M
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime, timedelta
from datetime import datetime
from faker import Faker
import random
fake = Faker()
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite3'
app.config['SQALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
# db.init(app)
class Customer(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(50), nullable=False)
last_name = db.Column(db.String(50), nullable=False)
address = db.Column(db.String(500), nullable=False)
city = db.Column(db.String(50), nullable=False)
postcode = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(50), nullable=False, unique=True)
orders = db.relationship(
'Order',
backref='customer') # second step to create relation - backreference
