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)