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)