class ImageSchema(Schema):
id = fields.Integer(dump_only=True)
height = fields.Integer(required=True)
width = fields.Integer(required=True)
time = fields.Integer(required=True)
timestamp = fields.DateTime(dump_only=True)
pic_num = fields.Integer(required=True)
filename = fields.String(dump_only=True)
image_path = fields.String(required=True, load_only=True)
@pre_dump
def _pre_dump(self, obj):
obj.timestamp = obj.time
class TesterSchema(Schema):
id = fields.Integer(dump_only=True)
test_id = fields.Integer(required=True)
time = fields.DateTime(required=True)
phone_manufacturer = fields.String(required=True)
phone_model = fields.String(required=True)
phone_screen_height = fields.String(required=True)
phone_screen_width = fields.String(required=True)
images_count = fields.Integer(dump_only=True)
images = fields.Nested(ImageSchema, many=True, dump_only=True)
@post_load
def _make_object(self, data):
return Tester(**data)
def test_load_from(self):
@self.app.route('/resource', methods=['GET'])
@self.io.from_query('param2', fields.Integer(load_from='param1'))
def test(param2):
self.assertEqual(param2, 10)
response = self.client.get('/resource?param1=10')
self.assertEqual(response.status_code, 204)
def test_empty_required_value(self):
@self.app.route('/resource', methods=['GET'])
@self.io.from_query('param1', fields.Integer(required=True))
def test(param1):
pass
response = self.client.get('/resource?param1=')
self.assertEqual(response.status_code, 400)
def test_fail_validate(self):
@self.app.route('/resource', methods=['GET'])
@self.io.from_query('param1',
fields.Integer(validate=lambda val: 1 <= val <= 10)
)
def test(param1):
pass
response = self.client.get('/resource?param1=11')
self.assertEqual(response.status_code, 400)
class UserSchema(Schema):
id = fields.Integer(dump_only=True)
email = fields.String(required=True)
password = fields.String(required=True)
enabled = fields.Boolean(dump_only=True)
updated_at = fields.DateTime(dump_only=True)
created_at = fields.DateTime(dump_only=True)
@post_dump
def make_object(self, data):
return User(**data)
class AppointmentSchema(Schema):
"""
Appointment Schema
"""
id = fields.Integer(dump_only=True)
client_name = fields.String(required=True)
request_date = fields.Date(required=False)
appointment_date = fields.Date(required=False)
appointment_time = fields.Time(required=False)
preferred_clinician = fields.String(required=True)
appointment_reason = fields.String(required=True)
class CompanySchema(Schema):
id = fields.Integer(dump_only=True)
name = fields.String(required=True)
country_code = fields.String(required=True)
website = fields.String(allow_none=True)
enabled = fields.Boolean(required=True)
updated_at = fields.DateTime(dump_only=True)
created_at = fields.DateTime(dump_only=True)
@post_load
def make_object(self, data):
return Company(**data)
class ProblemSchema(Schema):
id = fields.Integer(dump_only=True)
question = fields.String(required=True)
answer = fields.String(required=True)
distraction1 = fields.String(required=False)
distraction2 = fields.String(required=False)
distraction3 = fields.String(required=False)
distraction4 = fields.String(required=False)
distraction5 = fields.String(required=False)
@post_dump
def make_object(self, data):
return data
class IoTSchema(Schema):
id = fields.Integer(dump_only=True)
hmt = fields.String(allow_none=True)
tmp = fields.String(allow_none=True)
ppm = fields.String(allow_none=True)
lx = fields.String(allow_none=True)
ld = fields.String(allow_none=True)
time = fields.String(required=True)
date = fields.String(required=True)
timestamp = fields.String(required=True)
device = fields.String(required=False)
@post_dump
def make_object(self, data):
return IoTs(**data)
class FilterSchema(Schema):
search = fields.String(required=False)
sort = fields.String(required=False)
limit = fields.Integer(required=False)
page_start = fields.Integer(required=False)
def import_tester(tester):
"""
Import a user with a json body, see TesterSchema for input types.
:param tester:
:return:
"""
tester_persistor = TesterPersisor()
tester_persistor.add_tester(tester)
return tester
@app.route('/images', methods=['POST'])
@io.marshal_with(ImageSchema, envelope='images')
@io.from_header('tester_id', fields.Integer(required=True))
@io.from_body('image_data', ImageSchema(many=True))
def import_images(tester_id, image_data):
"""
Import images for a tester, see ImageSchema for input types.
Can import multiple images at once.
The path will have to be './images/xx.png'
Note: The function of this is poor, as the images are expected to be in the project folder...
In hindsight, choosing a serialisation package/library that better handles bulk files should have been a
priority.
:param tester_id:
:param image_data:
:return:
"""
@app.route('/<int:id>', methods=['GET'])
@io.marshal_with(CompanySchema)
def get_company(id):
company = Company.query.filter_by(id=id).first()
if not company:
return io.not_found('Company not found: ' + str(id))
return company
@app.route('/', methods=['GET'])
@io.from_query('name', fields.String())
@io.from_query('order_by', fields.String(missing='name'))
@io.from_query('offset', fields.Integer(missing=0))
@io.from_query('limit', fields.Integer(missing=10))
@io.marshal_with(CompanySchema)
def list_companies(name, order_by, offset, limit):
query = Company.query
if name:
query = query.filter(
func.lower(Company.name).contains(func.lower(name)))
if order_by:
query = sort_query(query, order_by)
if offset:
query = query.offset(offset)
if limit:
query = query.limit(limit)
class VideoSchema(Schema):
id = fields.Integer(dump_only=True)
tester_id = fields.Integer(dump_only=True)
duration = fields.Integer(dump_only=True)
time = fields.DateTime(dump_only=True)
filename = fields.String(dump_only=True)
@app.route('/users', methods=['POST'])
@io.from_body('user', UserSchema)
@io.marshal_with(UserSchema)
def add_user(user):
if store.get(user.username):
return io.conflict('User already exists: ' + user.username)
user.created_at = datetime.now()
store[user.username] = user
return user
@app.route('/users')
@io.from_query('username', fields.String())
@io.from_query('max_results', fields.Integer(missing=10))
@io.marshal_with(UserSchema)
def get_users(username, max_results):
users = list(store.values())
if username:
users = [user for user in users if user.username.find(username) > -1]
return users[:max_results]
@app.route('/users/<username>', methods=['POST'])
@io.from_body('new_user', UpdateUserSchema)
@io.marshal_with(UserSchema)
def update_user(username, new_user):
user = store.get(username)
"""
return {
'page': page,
'entries_per_page': entries_per_page,
'num_pages': num_entries // entries_per_page + 1,
'num_entries': num_entries
}
#-------------------#
# Work API Requests #
#-------------------#
@app.route('/work/', methods=['GET'])
@io.from_query('page', fields.Integer(missing=1))
@io.from_query('entries_per_page', fields.Integer(missing=25))
@io.from_query('order_by', fields.String(missing="name"))
@io.from_query('order', fields.String(missing="ascending"))
@io.from_query('startswith', fields.String(missing=None))
@io.from_query('art_type', fields.String(missing=None))
@io.from_query('medium', fields.String(missing=None))
@io.from_query('venue', fields.String(missing=None))
def get_works(page, entries_per_page, **kwargs):
"""
API GET request for all works of art in the database
"""
works = Work.query
# order results according to passed arguments
if kwargs['order_by']:
"""
Get a tester's image data by their ID.
:param tester_id:
:return:
"""
persistor = ImagePersisor()
if not persistor.ensure_tester_is_valid(tester_id):
return io.bad_request('Tester must have at least one image and video.')
return ImagePersisor().get_images(tester_id)
@app.route('/image/<image_id>', methods=['GET'])
@io.from_header('tester_id', fields.Integer(required=True))
def download_image(image_id, tester_id):
"""
Download an image by it's ID.
:param image_id:
:param tester_id:
:return:
"""
persistor = ImagePersisor()
if not persistor.ensure_tester_is_valid(tester_id):
return io.bad_request('Tester must have at least one image and video.')
image = persistor.get_image(image_id)
