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