def setUpClass(cls): """ This doesn't check defaults.' """ app = flask.Flask(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:" app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False api = flask_restful.Api(app) db = DBBase(app) cls.needs_setup = True @classmethod def set_db(cls): MlModel, Job, SmallBefore, SmallAfter = create_models(db) cls.MlModel = MlModel cls.Job = Job cls.SmallBefore = SmallBefore cls.SmallAfter = SmallAfter class Job(ModelResource): model_class = cls.Job class MlModel(ModelResource): model_class = cls.MlModel after_commit = {"post": JobCreator(class_name=cls.Job)} cls.api.add_resource(Job, *Job.get_urls()) cls.api.add_resource(MlModel, *MlModel.get_urls()) class SmallBefore(ModelResource): model_class = cls.SmallBefore before_commit = { "post": generic_adjustment, "put": generic_adjustment, "patch": generic_adjustment, "delete": generic_adjustment, } class SmallAfter(ModelResource): model_class = cls.SmallAfter after_commit = { "post": generic_adjustment, "put": generic_adjustment, "patch": generic_adjustment, } cls.api.add_resource(SmallBefore, *SmallBefore.get_urls()) cls.api.add_resource(SmallAfter, *SmallAfter.get_urls()) cls.needs_setup = False headers = {"Content-Type": "application/json"} cls.set_db = set_db cls.app = app cls.api = api cls.db = db cls.headers = headers
def setUpClass(cls): """ This doesn't check defaults.' """ app = flask.Flask(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:" app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False api = flask_restful.Api(app) db = DBBase(app) cls.needs_setup = True @classmethod def set_db(cls): Sample = create_samples(db) cls.Sample = Sample class SampleCollectionResource(CollectionModelResource): model_class = cls.Sample process_get_input = None order_by = None max_page_size = None cls.api.add_resource( SampleCollectionResource, *SampleCollectionResource.get_urls() ) class Sample1CollectionResource(CollectionModelResource): model_class = cls.Sample process_get_input = None order_by = "status_id" max_page_size = 5 cls.api.add_resource(Sample1CollectionResource, "/samples1") cls.needs_setup = False headers = {"Content-Type": "application/json"} cls.set_db = set_db cls.app = app cls.api = api cls.db = db cls.headers = headers
from flask_cors import CORS from flask_restful import Api, Resource from flask_restful_dbbase import DBBase from flask_restful_dbbase.resources import ( CollectionModelResource, ModelResource, MetaResource, ) app = Flask(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:" app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False api = Api(app) db = DBBase(app) CORS(app) URL_PREFIX = "/api/v1" all_metas = {} def add_meta(meta_resource): """ all_metas are keyed by res_endpoint. format: { res_endpoint: { meta_url: meta_resource.get_urls()[0] resource_urls: resource.get_urls() }
def setUpClass(cls): """ This doesn't check defaults.' """ app = flask.Flask(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:" app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False api = flask_restful.Api(app) db = DBBase(app) cls.needs_setup = True @classmethod def set_db(cls): Product = create_models(db) cls.Product = Product class ProductResource(ModelResource): model_class = cls.Product class ProductCollection(CollectionModelResource): model_class = cls.Product # alternate resource classes class ProductResource1(ModelResource): model_class = cls.Product url_prefix = "/api/v1" class ProductCollection1(CollectionModelResource): model_class = cls.Product url_prefix = "/api/v1" class ProductMetaResource(MetaResource): resource_class = ProductResource class ProductMetaCollection(MetaResource): resource_class = ProductCollection # alternate meta resource classes class ProductMetaResource1(MetaResource): resource_class = ProductResource1 class ProductMetaCollection1(MetaResource): resource_class = ProductCollection1 cls.api.add_resource(ProductResource, *ProductResource.get_urls()) cls.api.add_resource(ProductMetaResource, *ProductMetaResource.get_urls()) cls.api.add_resource(ProductMetaCollection, *ProductMetaCollection.get_urls()) cls.api.add_resource(ProductResource1, *ProductResource1.get_urls()) cls.api.add_resource(ProductMetaResource1, *ProductMetaResource1.get_urls()) cls.api.add_resource(ProductMetaCollection1, *ProductMetaCollection1.get_urls()) cls.ProductResource = ProductResource cls.ProductMetaResource = ProductMetaResource cls.ProductMetaCollection = ProductMetaCollection cls.ProductResource1 = ProductResource1 cls.ProductMetaResource1 = ProductMetaResource1 cls.ProductMetaCollection1 = ProductMetaCollection1 cls.needs_setup = False headers = {"Content-Type": "application/json"} cls.set_db = set_db cls.app = app cls.api = api cls.db = db cls.headers = headers
def setUpClass(cls): """ This doesn't check defaults.' """ app = flask.Flask(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:" app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False api = flask_restful.Api(app) db = DBBase(app) cls.needs_setup = True @classmethod def set_db(cls): Sample, OtherSample = create_samples(db) cls.Sample = Sample cls.OtherSample = OtherSample class OtherSampleResource(ModelResource): model_class = cls.OtherSample class SampleResource(ModelResource): model_class = cls.Sample method_decorators = [ # pretend_jwt_required ] # some test process input functions def process_get_input(self, qry, data, kwargs): # assumes pretend decorator # user_id = get_jwt_identity() user_id = 1 qry = qry.filter_by(owner_id=user_id) return True, (qry, data) def process_post_input(self, data): # assumes pretend decorator # user_id = get_jwt_identity() user_id = 1 # see how owner is camel case, data at this stage # is not yet deserialized if data.get("ownerId") == user_id: return True, data msg = "The user id does not match the owner id" return (False, ({"message": msg}, 400)) def process_put_input(self, qry, data, kwargs): # assumes pretend decorator # user_id = get_jwt_identity() user_id = 1 # see how owner is camel case, data at this stage # is not yet deserialized if data.get("ownerId") == user_id: return True, (qry, data) msg = "The user id does not match the owner id" return (False, ({"message": msg}, 400)) def process_patch_input(self, qry, data, kwargs): # assumes pretend decorator # user_id = get_jwt_identity() user_id = 1 # see how owner is camel case, data at this stage # is not yet deserialized if data.get("ownerId") == user_id: return True, (qry, data) return ( False, ( { "message": "The user id does not match the " "owner id" }, 400, ), ) def process_delete_input(self, qry, kwargs): # assumes pretend decorator # user_id = get_jwt_identity() user_id = 1 qry = qry.filter_by(owner_id=user_id) return True, qry cls.api.add_resource( OtherSampleResource, *OtherSampleResource.get_urls() ) cls.api.add_resource(SampleResource, *SampleResource.get_urls()) cls.needs_setup = False headers = {"Content-Type": "application/json"} cls.set_db = set_db cls.app = app cls.api = api cls.db = db cls.headers = headers
# tests/models/user_address.py import os from datetime import date, datetime from flask_restful_dbbase import DBBase os.environ["SQLALCHEMY_DATABASE_URI"] = ":memory:" db = DBBase() class User(db.Model): """ This class creates a simplified user model. Note that no security measures on the password are taken, this package has no opinion on the security model used. However, the info parameter is used to mark the password as write-only. The username is used as an id to test proper url generation """ __tablename__ = "user" # essential username = db.Column(db.String(80), primary_key=True, nullable=False) password = db.WriteOnlyColumn(db.String(80), nullable=False, info={"write-only": True}) email = db.Column(db.String(80), unique=True, nullable=False) first_name = db.Column(db.String(80), nullable=True) last_name = db.Column(db.String(80), nullable=True) company = db.Column(db.String(255), nullable=True)