def add_sample_metadata(resp): # pylint: disable=unused-argument """Update metadata for sample.""" try: post_data = request.get_json() sample_name = post_data['sample_name'] metadata = post_data['metadata'] except TypeError: raise ParseError('Missing Sample metadata payload.') except KeyError: raise ParseError('Invalid Sample metadata payload.') try: sample = Sample.objects.get(name=sample_name) except DoesNotExist: raise NotFound('Sample does not exist.') try: sample.metadata = metadata sample.save() result = sample_schema.dump(sample).data return result, 200 except ValidationError as validation_error: current_app.logger.exception('Sample metadata could not be updated.') raise ParseError( f'Invalid Sample metadata payload: {str(validation_error)}')
def add_sample_group(authn): # pylint: disable=too-many-locals """Add sample group.""" # Validate input try: data = request.get_json() name = data['name'] organization = Organization.query.filter_by( name=data['organization_name']).first() except TypeError as exc: current_app.logger.exception(f'Sample Group creation error:\n{exc}') raise ParseError(f'Missing Sample Group creation payload.\n{exc}') except KeyError: raise ParseError('Invalid Sample Group creation payload.') authn_user = User.query.filter_by(uuid=authn.sub).first() if authn_user.uuid not in organization.writer_uuids(): raise PermissionDenied( 'You do not have permission to write to that organization.') # Create Sample Group try: sample_group = SampleGroup( name=name, organization_uuid=organization.uuid, description=data.get('description', False), is_library=data.get('is_library', False), is_public=data.get('is_public', False), ).save() return sample_group.serializable(), 201 except IntegrityError as integrity_error: current_app.logger.exception('Sample Group could not be created.') raise ParseError('Duplicate group name.')
def add_organization_user(authn, organization_uuid): # pylint: disable=too-many-return-statements """Add user to organization.""" try: post_data = request.get_json() organization = Organization.from_uuid(UUID(organization_uuid)) admin = User.from_uuid(authn.sub) except TypeError: raise ParseError('Missing membership payload.') except ValueError: raise ParseError('Invalid organization UUID.') except NoResultFound: raise NotFound('Organization does not exist') try: user = User.from_uuid(post_data['user_uuid']) except KeyError: raise ParseError('Invalid membership payload.') except NoResultFound: raise NotFound('User does not exist') if admin.uuid in organization.admin_uuids(): if user.uuid in organization.reader_uuids(): raise InvalidRequest('User is already part of organization.') role = post_data.get('role', 'read') try: organization.add_user(user, role_in_org=role) result = {'message': f'${user.username} added to ${organization.name}'} return result, 200 except IntegrityError as integrity_error: current_app.logger.exception('IntegrityError encountered.') raise InternalError(str(integrity_error)) raise PermissionDenied('You do not have permission to add a user to that organization.')
def add_sample_group(resp): # pylint: disable=unused-argument """Add sample group.""" try: post_data = request.get_json() name = post_data['name'] except TypeError: raise ParseError('Missing Sample Group creation payload.') except KeyError: raise ParseError('Invalid Sample Group creation payload.') sample_group = SampleGroup.query.filter_by(name=name).first() if sample_group is not None: raise InvalidRequest('Sample Group with that name already exists.') try: analysis_result = AnalysisResultMeta().save() sample_group = SampleGroup(name=name, analysis_result=analysis_result) db.session.add(sample_group) db.session.commit() result = sample_group_schema.dump(sample_group).data return result, 201 except IntegrityError as integrity_error: current_app.logger.exception('Sample Group could not be created.') db.session.rollback() raise InternalError(str(integrity_error))
def view_function(resp, uuid): """Wrap receive_upload to provide class.""" if issubclass(cls, SampleToolResultModule): return receive_sample_tool_upload(cls, resp, uuid) elif issubclass(cls, GroupToolResultModule): return receive_group_tool_upload(cls, resp, uuid) raise ParseError('Tool Result of unrecognized type.')
def add_samples_to_group(authn, group_uuid): """Add samples to a sample group.""" try: post_data = request.get_json() sample_group = SampleGroup.query.filter_by(uuid=UUID(group_uuid)).one() except ValueError: raise ParseError('Invalid Sample Group UUID.') except NoResultFound: raise NotFound('Sample Group does not exist') authn_user = User.query.filter_by(uuid=authn.sub).first() organization = Organization.query.filter_by( uuid=sample_group.organization_uuid).first() if authn_user.uuid not in organization.writer_uuids(): raise PermissionDenied( 'You do not have permission to write to that organization.') for sample_uuid in [UUID(uuid) for uuid in post_data.get('sample_uuids')]: try: sample = Sample.query.filter_by(uuid=sample_uuid).first() sample_group.samples.append(sample) except NoResultFound: raise InvalidRequest( f'Sample UUID \'{sample_uuid}\' does not exist') except IntegrityError as integrity_error: current_app.logger.exception( f'Sample \'{sample_uuid}\' could not be added to Sample Group.' ) raise InternalError(str(integrity_error)) sample_group.save() result = sample_group.serializable() return result, 200
def add_samples_to_group(resp, group_uuid): # pylint: disable=unused-argument """Add samples to a sample group.""" try: post_data = request.get_json() sample_group_id = UUID(group_uuid) sample_group = SampleGroup.query.filter_by(id=sample_group_id).one() except ValueError: raise ParseError('Invalid Sample Group UUID.') except NoResultFound: raise NotFound('Sample Group does not exist') try: sample_uuids = [UUID(uuid) for uuid in post_data.get('sample_uuids')] for sample_uuid in sample_uuids: sample = Sample.objects.get(uuid=sample_uuid) sample_group.sample_ids.append(sample.uuid) db.session.commit() result = sample_group_schema.dump(sample_group).data return result, 200 except NoResultFound: db.session.rollback() raise InvalidRequest(f'Sample UUID \'{sample_uuid}\' does not exist') except IntegrityError as integrity_error: current_app.logger.exception('Samples could not be added to Sample Group.') db.session.rollback() raise InternalError(str(integrity_error))
def get_single_sample_group(group_uuid): """Get single sample group model.""" try: sample_group = SampleGroup.query.filter_by(uuid=UUID(group_uuid)).one() return sample_group.serializable(), 200 except ValueError: raise ParseError('Invalid Sample Group UUID.') except NoResultFound: raise NotFound('Sample Group does not exist')
def get_single_organization(organization_uuid): """Get single organization details.""" try: org = Organization.from_uuid(UUID(organization_uuid)) return org.serializable(), 200 except ValueError: raise ParseError('Invalid organization UUID.') except NoResultFound: raise NotFound('Organization does not exist')
def add_organization(authn): """Add organization.""" try: post_data = request.get_json() org_name = post_data['name'] primary_admin = User.from_uuid(authn.sub) is_public = post_data.get('is_public', True) except NoResultFound: raise NotFound('User does not exist') except TypeError: raise ParseError('Missing organization payload.') except KeyError: raise ParseError('Invalid organization payload.') try: org = Organization.from_user(primary_admin, org_name, is_public=is_public) return org.serializable(), 201 except IntegrityError: current_app.logger.exception('There was a problem adding an organization.') raise InternalError(str(integrity_error))
def get_metadata_from_request(request): try: metadata_file = request.files['metadata'] except KeyError: raise ParseError('Missing metadata file attachment.') if metadata_file.filename == '': raise ParseError('Missing metadata file attachment.') try: extension = metadata_file.filename.split('.')[1] except KeyError: raise ParseError('Metadata file missing extension.') stream = StringIO(metadata_file.stream.read().decode('UTF8'), newline=None) if extension == 'csv': metadata = DictReader(stream) elif 'xls' in extension: metadata = XLSDictReader(stream) else: raise ParseError('Missing valid metadata file attachment.') return metadata
def login_user(): """Log user in.""" try: post_data = request.get_json() email = post_data['email'] password = post_data['password'] except TypeError: raise ParseError('Missing login payload.') except KeyError: raise ParseError('Invalid login payload.') # Fetch the user data user = User.query.filter_by(email=email).first() if user and bcrypt.check_password_hash(user.password, password): auth_token = user.encode_auth_token(user.id) if auth_token: result = {'auth_token': auth_token.decode()} return result, 200 raise NotFound('User does not exist.')
def get_all_analysis_results(): """Get all analysis result models.""" try: analysis_results = AnalysisResultMeta.objects.all() result = analysis_result_schema.dump(analysis_results, many=True).data return result, 200 except ValueError: raise ParseError('Invalid UUID provided.') except DoesNotExist: raise NotFound('Analysis Result does not exist.')
def get_single_result(group_uuid): """Get single sample group model.""" try: sample_group_id = UUID(group_uuid) sample_group = SampleGroup.query.filter_by(id=sample_group_id).one() result = sample_group_schema.dump(sample_group).data return result, 200 except ValueError: raise ParseError('Invalid Sample Group UUID.') except NoResultFound: raise NotFound('Sample Group does not exist')
def get_single_result(result_uuid): """Get single analysis result.""" try: uuid = UUID(result_uuid) analysis_result = AnalysisResultMeta.objects.get(uuid=uuid) result = analysis_result_schema.dump(analysis_result).data return result, 200 except ValueError: raise ParseError('Invalid UUID provided.') except DoesNotExist: raise NotFound('Analysis Result does not exist.')
def get_single_sample(sample_uuid): """Get single sample details.""" try: uuid = UUID(sample_uuid) sample = Sample.objects.get(uuid=uuid) fields = ('uuid', 'name', 'analysis_result_uuid', 'created_at') result = SampleSchema(only=fields).dump(sample).data return result, 200 except ValueError: raise ParseError('Invalid UUID provided.') except DoesNotExist: raise NotFound('Sample does not exist.')
def get_samples_for_group_by_name(group_name): """Get single sample group's list of samples.""" try: sample_group = SampleGroup.from_name(group_name) result = { 'samples': [sample.serializable() for sample in sample_group.samples], } return result, 200 except ValueError: raise ParseError('Invalid Sample Group UUID.') except NoResultFound: raise NotFound('Sample Group does not exist')
def get_samples_for_group(group_uuid): """Get single sample group's list of samples.""" try: sample_group = SampleGroup.query.filter_by(uuid=UUID(group_uuid)).one() result = { 'samples': [sample.serializable() for sample in sample_group.samples], } return result, 200 except ValueError: raise ParseError('Invalid Sample Group UUID.') except NoResultFound: raise NotFound('Sample Group does not exist')
def get_samples_for_group(group_uuid): """Get single sample group's list of samples.""" try: sample_group_id = UUID(group_uuid) sample_group = SampleGroup.query.filter_by(id=sample_group_id).one() samples = sample_group.samples current_app.logger.info(f'Found {len(samples)} samples for group {group_uuid}') result = SampleSchema(only=('uuid', 'name')).dump(samples, many=True).data return result, 200 except ValueError: raise ParseError('Invalid Sample Group UUID.') except NoResultFound: raise NotFound('Sample Group does not exist')
def receive_sample_tool_upload(cls, resp, uuid): """Define handler for receiving uploads of analysis tool results.""" try: safe_uuid = UUID(uuid) sample = Sample.objects.get(uuid=safe_uuid) except ValueError: raise ParseError('Invalid UUID provided.') except DoesNotExist: raise NotFound('Sample does not exist.') # gh-21: Write actual validation: try: auth_user = User.query.filter_by(id=resp).one() print(auth_user) except NoResultFound: raise PermissionDenied('Authorization failed.') try: payload = request.get_json() payload = cls.run_upload_hooks(payload) tool_result = cls.make_result_model(payload).save() setattr(sample, cls.name(), tool_result) sample.save() except ValidationError as validation_error: raise ParseError(str(validation_error)) # Kick off middleware tasks dryrun = request.args.get('dryrun', False) if not dryrun: try: downstream_modules = SampleConductor.downstream_modules(cls) SampleConductor(safe_uuid, downstream_modules).shake_that_baton() except Exception: # pylint: disable=broad-except current_app.logger.exception( 'Exception while coordinating display modules.') # Return payload here to avoid per-class JSON serialization return payload, 201
def add_sample(resp): # pylint: disable=unused-argument """Add sample.""" try: post_data = request.get_json() sample_group_uuid = post_data['sample_group_uuid'] sample_name = post_data['name'] except TypeError: raise ParseError('Missing Sample creation payload.') except KeyError: raise ParseError('Invalid Sample creation payload.') try: sample_group = SampleGroup.query.filter_by(id=sample_group_uuid).one() except NoResultFound: raise InvalidRequest('Sample Group does not exist!') sample = Sample.objects(name=sample_name).first() if sample is not None: raise InvalidRequest('A Sample with that name already exists.') try: analysis_result = AnalysisResultMeta().save() sample = Sample(name=sample_name, analysis_result=analysis_result, metadata={ 'name': sample_name }).save() sample_group.sample_ids.append(sample.uuid) db.session.commit() result = sample_schema.dump(sample).data return result, 201 except ValidationError as validation_error: current_app.logger.exception('Sample could not be created.') raise InternalError(str(validation_error)) except IntegrityError as integrity_error: current_app.logger.exception( 'Sample could not be added to Sample Group.') db.session.rollback() raise InternalError(str(integrity_error))
def run_sample_group_display_modules(uuid): # pylint: disable=invalid-name """Run display modules for sample group.""" try: safe_uuid = UUID(uuid) _ = SampleGroup.query.filter_by(uuid=safe_uuid).first() except ValueError: raise ParseError('Invalid UUID provided.') except NoResultFound: raise NotFound('Sample Group does not exist.') analysis_names = request.args.getlist('analysis_names') TaskConductor(uuid, analysis_names).shake_that_baton() result = {'middleware': analysis_names} return result, 202
def register_user(): """Register user.""" try: post_data = request.get_json() username = post_data['username'] email = post_data['email'] password = post_data['password'] except TypeError: raise ParseError('Missing registration payload.') except KeyError: raise ParseError('Invalid registration payload.') # Check for existing user user = User.query.filter( or_(User.username == username, User.email == email)).first() if user is not None: raise InvalidRequest('Sorry. That user already exists.') try: # Add new user to db new_user = User( username=username, email=email, password=password, ) db.session.add(new_user) db.session.commit() except IntegrityError as integrity_error: current_app.logger.exception('There was a problem with registration.') db.session.rollback() raise InternalError(str(integrity_error)) # Generate auth token auth_token = new_user.encode_auth_token(new_user.id) result = {'auth_token': auth_token.decode()} return result, 201