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_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_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 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 get_all_analysis_results():
"""Get all analysis result models."""
try:
result = [ar.serializable() for ar in SampleAnalysisResult.all()]
result += [ar.serializable() for ar in SampleGroupAnalysisResult.all()]
return result, 200
except DoesNotExist:
raise NotFound('Analysis Result does not exist.')
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_sample(sample_uuid):
"""Get single sample details."""
try:
sample = Sample.from_uuid(UUID(sample_uuid))
return sample.serializable(), 200
except ValueError:
raise ParseError('Invalid UUID provided.')
except DoesNotExist:
raise NotFound('Sample 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 fetch_organization(organization_uuid):
"""Get organization from UUID string."""
try:
organization_uuid = uuid.UUID(organization_uuid)
organization = User.query.filter_by(uuid=organization_uuid).one()
return organization
except ValueError:
raise ParseError('Invalid organization UUID.')
except NoResultFound:
raise NotFound('Organization does not exist')
def get_single_result(result_uuid):
"""Get single analysis result."""
try:
analysis_result = get_analysis_result(result_uuid)
result = analysis_result.serializable()
return result, 200
except ValueError:
raise ParseError('Invalid UUID provided.')
except DoesNotExist:
raise NotFound('Analysis Result 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(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_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_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 get_sample_group_uuid(sample_group_name):
"""Return the UUID associated with a single sample."""
try:
sample_group = SampleGroup.query.filter_by(name=sample_group_name).one()
except NoResultFound:
raise NotFound('Sample Group does not exist')
sample_group_uuid = sample_group.id
result = {
'sample_group_name': sample_group_name, # recapitulate for convenience
'sample_group_uuid': sample_group_uuid,
}
return result, 200
def get_sample_uuid(sample_name):
"""Return the UUID associated with a single sample."""
try:
sample = Sample.objects.get(name=sample_name)
except DoesNotExist:
raise NotFound('Sample does not exist.')
sample_uuid = sample.uuid
result = {
'sample_name': sample_name, # recapitulate for convenience
'sample_uuid': sample_uuid,
}
return result, 200
def get_group_analysis_result_fields_by_name(group_name, module_name):
"""Get all fields of the specified analysis result."""
try:
group = SampleGroup.from_name(group_name)
analysis_result = SampleGroupAnalysisResult.from_name_group(
module_name, group.uuid)
result = {
field.field_name: field.data
for field in analysis_result.module_fields
}
return result, 200
except NoResultFound:
raise NotFound('Analysis Result does not exist.')
def get_analysis_result_fields_by_name(lib_name, sample_name, module_name):
"""Get all fields of the specified analysis result."""
try:
library = SampleGroup.from_name(lib_name)
sample = Sample.from_name_library(sample_name, library.uuid)
analysis_result = SampleAnalysisResult.from_name_sample(
module_name, sample.uuid)
result = {
field.field_name: field.data
for field in analysis_result.module_fields
}
return result, 200
except NoResultFound:
raise NotFound('Analysis Result does not exist.')
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 post_single_sample_metadata(sample_uuid):
"""Upload metadata for a single sample."""
try:
post_data = request.get_json()
sample = Sample.from_uuid(UUID(sample_uuid))
sample.set_sample_metadata(post_data['metadata'])
return sample.serializable(), 200
except ValueError:
raise ParseError('Invalid UUID provided.')
except DoesNotExist:
raise NotFound('Sample does not exist.')
except TypeError:
raise ParseError('Missing Sample metadata payload.')
except KeyError:
raise ParseError('Invalid Sample metadata payload.')
def get_single_sample_metadata(sample_uuid):
"""Get single sample metadata."""
try:
sample = Sample.from_uuid(UUID(sample_uuid))
result = {
'sample': {
'uuid': sample.uuid,
'name': sample.name,
'metadata': sample.sample_metadata,
},
}
return result, 200
except ValueError:
raise ParseError('Invalid UUID provided.')
except DoesNotExist:
raise NotFound('Sample does not exist.')
def get_organizations():
"""Get all organizations."""
if 'name' in request.args:
name_query = request.args.get('name')
try:
organization = Organization.from_name(name_query)
except NoResultFound:
raise NotFound('Organization does not exist')
return organization.serializable(), 200
limit = request.args.get('limit', PAGE_SIZE)
offset = request.args.get('offset', 0)
organizations = Organization.query.all()
organizations = sorted(organizations, key=lambda el: str(User.created_at))
organizations = organizations[offset:(offset + limit)]
result = {'organizations': [org.serializable() for org in organizations]}
return result, 200
def get_all_samples(authn): # pylint: disable=unused-argument
"""Get all samples that the user is allowed to see."""
try:
org_uuids = {membership.uuid for membership in authn.memberships}
sample_groups = SampleGroup.query.filter(
and_(
SampleGroup.is_library,
or_(SampleGroup.is_public, SampleGroup.organization_uuid
in org_uuids))).all()
samples = []
for sample_group in sample_groups:
for sample in sample_group.samples:
samples.append(sample.serializable())
result = {'samples': samples}
return result, 200
except NoResultFound:
raise NotFound('No accessible samples found.')
def jira_issue_transition_update():
if not helper.check_github_ip(src_ip=request.access_route[0]):
raise NotAcceptable('Github IP whitelist check failed! IP: {}'.format(
request.access_route[0]))
if not helper.check_github_pull_request_payload(payload=request.json):
raise NotAcceptable('Json payload is not valid')
# detect issue_id
issue_id = jiraservice.get_issue_id_from_github_payload(
payload=request.json)
if not issue_id:
raise NotAcceptable('Issue could not detect')
# new pull request state (approve,changes_request,commented)
pr_state = request.json['review']['state']
# get new transition id from env with project prefix.
transition_id = helper.get_transition_id(pr_state)
if not transition_id:
raise NotFound('New transition id not found on your env')
# send update request to jira API
response = jiraservice.issue_transition_update(
issue_id=issue_id, new_transition_id=transition_id)
if pr_state in [APPROVED, CHANGES_REQUESTED]:
pr_number = request.json['pull_request']['number']
issue_owner_username = request.json['pull_request']['user']['login']
reviewer_username = request.json['review']['user']['login']
helper.save_pull_request_review(
issue_id=issue_id,
pr_id=pr_number,
issue_owner_username=issue_owner_username,
reviewer_username=reviewer_username,
action=pr_state)
if response:
return jsonify({'ack': 'OK'})
else:
return jsonify({'ack': 'NOT OK'})
if __name__ == '__main__':
application.run(debug=True)
def wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except HttpException as e:
if isinstance(e, UnauthorizedException):
raise PermissionDenied(e.args)
elif isinstance(e, NotFoundException):
raise NotFound(e.args)
elif isinstance(e, BadRequestException):
raise ParseError(e.args)
else:
if has_sentry:
sentry_sdk.capture_exception(e)
raise APIException(e.args)
except Exception as e:
if has_sentry:
sentry_sdk.capture_exception(e)
raise APIException('%s: %s' % (e.__class__.__name__, str(e)))
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 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.')
