def test_get_by_id(self):
self.release_group_query_with_artists.return_value = [
releasegroup_numb_encore
]
release_group = mb_release_group.get_release_group_by_id(
'7c1014eb-454c-3867-8854-3c95d265f8de', )
self.assertEqual(release_group['id'],
'7c1014eb-454c-3867-8854-3c95d265f8de')
self.assertEqual(release_group['title'], 'Numb/Encore')
# Check if multiple artists are properly fetched
self.assertEqual(release_group['artist-credit-phrase'],
'Jay-Z/Linkin Park')
self.assertDictEqual(
release_group['artist-credit'][0], {
'name': 'Jay-Z',
'artist': {
'id': 'f82bcf78-5b69-4622-a5ef-73800768d9ac',
'name': 'JAY Z',
'sort_name': 'JAY Z'
},
'join_phrase': '/',
})
self.assertDictEqual(
release_group['artist-credit'][1], {
'name': 'Linkin Park',
'artist': {
'id': 'f59c5520-5f46-4d2c-b2c4-822eabf53419',
'name': 'Linkin Park',
'sort_name': 'Linkin Park',
},
})
def test_get_by_id(self):
self.release_group_query_with_artists.return_value = [releasegroup_numb_encore]
release_group = mb_release_group.get_release_group_by_id(
'7c1014eb-454c-3867-8854-3c95d265f8de',
)
self.assertEqual(release_group['id'], '7c1014eb-454c-3867-8854-3c95d265f8de')
self.assertEqual(release_group['title'], 'Numb/Encore')
# Check if multiple artists are properly fetched
self.assertEqual(release_group['artist-credit-phrase'], 'Jay-Z/Linkin Park')
self.assertDictEqual(release_group['artist-credit'][0], {
'name': 'Jay-Z',
'artist': {
'id': 'f82bcf78-5b69-4622-a5ef-73800768d9ac',
'name': 'JAY Z',
'sort_name': 'JAY Z'
},
'join_phrase': '/',
})
self.assertDictEqual(release_group['artist-credit'][1], {
'name': 'Linkin Park',
'artist': {
'id': 'f59c5520-5f46-4d2c-b2c4-822eabf53419',
'name': 'Linkin Park',
'sort_name': 'Linkin Park',
},
})
def entity(id):
id = str(id)
try:
release_group = mb_release_group.get_release_group_by_id(id)
except mb_exceptions.NoDataFoundException:
raise NotFound(
gettext(
"Sorry, we couldn't find a release group with that MusicBrainz ID."
))
if 'tag-list' in release_group:
tags = release_group['tag-list']
else:
tags = None
if 'release-list' in release_group and release_group['release-list']:
release = mb_release.get_release_by_id(
release_group['release-list'][0]['id'])
else:
release = None
soundcloud_url = soundcloud.get_url(release_group['id'])
if soundcloud_url:
spotify_mappings = None
else:
spotify_mappings = mbspotify.mappings(release_group['id'])
limit = int(request.args.get('limit', default=10))
offset = int(request.args.get('offset', default=0))
if current_user.is_authenticated:
my_reviews, my_count = db_review.list_reviews(
entity_id=release_group['id'],
entity_type='release_group',
user_id=current_user.id,
)
if my_count != 0:
my_review = my_reviews[0]
else:
my_review = None
else:
my_review = None
reviews, count = db_review.list_reviews(
entity_id=release_group['id'],
entity_type='release_group',
sort='popularity',
limit=limit,
offset=offset,
)
avg_rating = get_avg_rating(release_group['id'], "release_group")
return render_template('release_group/entity.html',
id=release_group['id'],
release_group=release_group,
reviews=reviews,
release=release,
my_review=my_review,
spotify_mappings=spotify_mappings,
tags=tags,
soundcloud_url=soundcloud_url,
limit=limit,
offset=offset,
count=count,
avg_rating=avg_rating)
def test_release_group_cache(self, release_group_fetch, cache_set,
cache_get):
mbid = "7c1014eb-454c-3867-8854-3c95d265f8de"
expected_key = b"release-group_7c1014eb-454c-3867-8854-3c95d265f8de"
release_group = {
'id':
'7c1014eb-454c-3867-8854-3c95d265f8de',
'title':
'Numb/Encore',
'artist-credit-phrase':
'Jay-Z/Linkin Park',
'artist-credit': [{
'name': 'Jay-Z',
'artist': {
'id': 'f82bcf78-5b69-4622-a5ef-73800768d9ac',
'name': 'JAY Z',
'sort_name': 'JAY Z'
},
'join_phrase': '/',
}]
}
release_group_fetch.return_value = {mbid: release_group}
cache_get.return_value = None
get_release_group_by_id(mbid)
# Test that first time data is fetched database is queried
cache_get.assert_called_with(expected_key)
release_group_fetch.assert_called_with([mbid],
includes=[
'artists', 'releases',
'release-group-rels',
'url-rels', 'tags'
])
cache_set.assert_called_with(key=expected_key,
val=release_group,
time=DEFAULT_CACHE_EXPIRATION)
cache_get.return_value = release_group
cache_set.reset_mock()
release_group_fetch.reset_mock()
get_release_group_by_id(mbid)
# Test that second time data is fetched from cache
cache_get.assert_called_with(expected_key)
release_group_fetch.assert_not_called()
cache_set.assert_not_called()
def get_entity_by_id(id, type='release_group'):
"""A wrapper to call the correct get_*_by_id function."""
if type == 'release_group':
entity = get_release_group_by_id(str(id))
elif type == 'place':
entity = get_place_by_id(str(id))
elif type == 'event':
entity = get_event_by_id(str(id))
return entity
def spotify_confirm():
"""Confirmation page for adding new Spotify mapping."""
release_group_id = request.args.get('release_group_id')
if not release_group_id:
raise BadRequest("Didn't provide `release_group_id`!")
try:
release_group = mb_release_group.get_release_group_by_id(
release_group_id)
except mb_exceptions.NoDataFoundException:
flash.error(
gettext("Only existing release groups can be mapped to Spotify!"))
return redirect(url_for('search.index'))
spotify_ref = request.args.get('spotify_ref', default=None)
if not spotify_ref:
flash.error(gettext("You need to select an album from Spotify!"))
return redirect(
url_for('.spotify_add', release_group_id=release_group_id))
try:
spotify_id = parse_spotify_id(spotify_ref)
except UnsupportedSpotifyReferenceTypeException:
flash.error(
gettext(
"You need to specify a correct link to this album on Spotify!")
)
return redirect(
url_for('.spotify_add', release_group_id=release_group_id))
except Exception:
raise BadRequest("Could not parse Spotify ID!")
try:
album = spotify_api.get_album(spotify_id)
except ExternalServiceException:
flash.error(
gettext("You need to specify existing album from Spotify!"))
return redirect(
url_for('.spotify_add', release_group_id=release_group_id))
if request.method == 'POST':
# TODO(roman): Check values that are returned by add_mapping (also take a look at related JS).
res, error = mbspotify.add_mapping(release_group_id,
'spotify:album:%s' % spotify_id,
current_user.id)
if res:
flash.success(gettext("Spotify mapping has been added!"))
else:
flash.error(gettext("Could not add Spotify mapping!"))
current_app.logger.error(
"Failed to create new Spotify mapping! Error: {}".format(
error))
return redirect(
url_for('.spotify_list', release_group_id=release_group_id))
return render_template('mapping/confirm.html',
release_group=release_group,
spotify_album=album)
def spotify_report():
"""Endpoint for reporting incorrect Spotify mappings.
Shows confirmation page before submitting report to mbspotify.
"""
release_group_id = request.args.get('release_group_id')
if not release_group_id:
raise BadRequest("Didn't provide `release_group_id`!")
spotify_id = request.args.get('spotify_id')
if not spotify_id:
raise BadRequest("Didn't provide `spotify_id`!")
spotify_uri = "spotify:album:" + spotify_id
# Checking if release group exists
try:
release_group = mb_release_group.get_release_group_by_id(
release_group_id)
except mb_exceptions.NoDataFoundException:
raise NotFound("Can't find release group with a specified ID.")
# Checking if release group is mapped to Spotify
spotify_mappings = mbspotify.mappings(str(release_group_id))
if spotify_uri not in spotify_mappings:
flash.error(gettext("This album is not mapped to Spotify yet!"))
return redirect(
url_for('.spotify_list', release_group_id=release_group_id))
if request.method == 'POST':
res, error = mbspotify.vote(release_group_id, spotify_uri,
current_user.id)
if res:
flash.success(
gettext(
"Incorrect Spotify mapping has been reported. Thank you!"))
else:
flash.error(gettext("Could not report incorrect Spotify mapping!"))
current_app.logger.error(
"Failed to report incorrect Spotify mapping! Error: {}".format(
error))
return redirect(
url_for('.spotify_list', release_group_id=release_group_id))
try:
album = spotify_api.get_album(spotify_id)
except ExternalServiceException:
flash.error(
gettext("You need to specify existing album from Spotify!"))
return redirect(
url_for('.spotify_list', release_group_id=release_group_id))
return render_template('mapping/report.html',
release_group=release_group,
spotify_album=album)
def entity(id):
id = str(id)
try:
release_group = mb_release_group.get_release_group_by_id(id)
except mb_exceptions.NoDataFoundException:
raise NotFound(gettext("Sorry, we couldn't find a release group with that MusicBrainz ID."))
if 'url-rels' in release_group:
external_reviews = list(filter(lambda rel: rel['type'] == 'review', release_group['url-rels']))
else:
external_reviews = []
if 'tag-list' in release_group:
tags = release_group['tag-list']
else:
tags = None
if 'release-list' in release_group and release_group['release-list']:
release = mb_release.get_release_by_id(release_group['release-list'][0]['id'])
else:
release = None
soundcloud_url = soundcloud.get_url(release_group['id'])
if soundcloud_url:
spotify_mappings = None
else:
spotify_mappings = mbspotify.mappings(release_group['id'])
limit = int(request.args.get('limit', default=10))
offset = int(request.args.get('offset', default=0))
if current_user.is_authenticated:
my_reviews, my_count = db_review.list_reviews(
entity_id=release_group['id'],
entity_type='release_group',
user_id=current_user.id,
)
my_review = my_reviews[0] if my_count else None
else:
my_review = None
reviews, count = db_review.list_reviews(
entity_id=release_group['id'],
entity_type='release_group',
sort='popularity',
limit=limit,
offset=offset,
)
avg_rating = get_avg_rating(release_group['id'], "release_group")
rating_form = RatingEditForm(entity_id=id, entity_type='release_group')
rating_form.rating.data = my_review['rating'] if my_review else None
return render_template('release_group/entity.html', id=release_group['id'], release_group=release_group, reviews=reviews,
release=release, my_review=my_review, spotify_mappings=spotify_mappings, tags=tags,
soundcloud_url=soundcloud_url, external_reviews=external_reviews, limit=limit, offset=offset,
count=count, avg_rating=avg_rating, rating_form=rating_form, current_user=current_user)
def spotify_add():
release_group_id = request.args.get('release_group_id')
if not release_group_id:
return redirect(url_for('frontend.index'))
try:
release_group = mb_release_group.get_release_group_by_id(
release_group_id)
except mb_exceptions.NoDataFoundException:
flash.error(
gettext("Only existing release groups can be mapped to Spotify!"))
return redirect(url_for('search.index'))
page = int(request.args.get('page', default=1))
if page < 1:
return redirect(url_for('.spotify_add'))
limit = 16
offset = (page - 1) * limit
# Removing punctuation from the string
punctuation_map = dict((ord(char), None) for char in string.punctuation)
query = release_group['title'].translate(punctuation_map)
# Searching...
try:
response = spotify_api.search(query,
item_types='album',
limit=limit,
offset=offset).get('albums')
except ExternalServiceException as e:
current_app.logger.error("Error while searching Spotify API: %s",
str(e),
exc_info=True)
raise ServiceUnavailable(e)
albums_ids = [x['id'] for x in response['items']]
try:
full_response = spotify_api.get_multiple_albums(albums_ids)
except ExternalServiceException as e:
current_app.logger.error("Error while getting albums from Spotify: %s",
str(e),
exc_info=True)
raise ServiceUnavailable(e)
search_results = [
full_response[id] for id in albums_ids if id in full_response
]
return render_template('mapping/spotify.html',
release_group=release_group,
search_results=search_results,
page=page,
limit=limit,
count=response.get('total'))
def test_unknown_release_group(self):
self.release_group_query.return_value = []
mb_utils.reviewed_entities = MagicMock()
mb_utils.reviewed_entities.return_value = ['8ef859e3-feb2-4dd1-93da-22b91280d7df']
release_group = mb_release_group.get_release_group_by_id('8ef859e3-feb2-4dd1-93da-22b91280d7df')
self.assertEqual(release_group['title'], '[Unknown Release Group]')
self.assertListEqual(release_group['artist-credit'], [{
'name': '[unknown]',
'artist': {
'id': '125ec42a-7229-4250-afc5-e057484327fe',
'name': '[unknown]',
'sort_name': '[unknown]'
}
}])
def test_unknown_release_group(self):
self.release_group_query.return_value = []
mb_utils.reviewed_entities = MagicMock()
mb_utils.reviewed_entities.return_value = [
'8ef859e3-feb2-4dd1-93da-22b91280d7df'
]
release_group = mb_release_group.get_release_group_by_id(
'8ef859e3-feb2-4dd1-93da-22b91280d7df')
self.assertEqual(release_group['title'], '[Unknown Release Group]')
self.assertListEqual(release_group['artist-credit'], [{
'name': '[unknown]',
'artist': {
'id': '125ec42a-7229-4250-afc5-e057484327fe',
'name': '[unknown]',
'sort_name': '[unknown]'
}
}])
def spotify_report():
"""Endpoint for reporting incorrect Spotify mappings.
Shows confirmation page before submitting report to mbspotify.
"""
release_group_id = request.args.get('release_group_id')
if not release_group_id:
raise BadRequest("Didn't provide `release_group_id`!")
spotify_id = request.args.get('spotify_id')
if not spotify_id:
raise BadRequest("Didn't provide `spotify_id`!")
spotify_uri = "spotify:album:" + spotify_id
# Checking if release group exists
try:
release_group = mb_release_group.get_release_group_by_id(release_group_id)
except mb_exceptions.NoDataFoundException:
raise NotFound("Can't find release group with a specified ID.")
# Checking if release group is mapped to Spotify
spotify_mappings = mbspotify.mappings(str(release_group_id))
if spotify_uri not in spotify_mappings:
flash.error(gettext("This album is not mapped to Spotify yet!"))
return redirect(url_for('.spotify_list', release_group_id=release_group_id))
if request.method == 'POST':
res, error = mbspotify.vote(release_group_id, spotify_uri, current_user.id)
if res:
flash.success(gettext("Incorrect Spotify mapping has been reported. Thank you!"))
else:
flash.error(gettext("Could not report incorrect Spotify mapping!"))
current_app.logger.error("Failed to report incorrect Spotify mapping! Error: {}".format(error))
return redirect(url_for('.spotify_list', release_group_id=release_group_id))
try:
album = spotify_api.get_album(spotify_id)
except ExternalServiceException:
flash.error(gettext("You need to specify existing album from Spotify!"))
return redirect(url_for('.spotify_list', release_group_id=release_group_id))
return render_template('mapping/report.html', release_group=release_group, spotify_album=album)
def spotify_report():
"""Endpoint for reporting incorrect Spotify mappings.
Shows confirmation page before submitting report to mbspotify.
"""
release_group_id = request.args.get('release_group_id')
spotify_id = request.args.get('spotify_id')
spotify_uri = "spotify:album:" + spotify_id
# Checking if release group exists
try:
release_group = mb_release_group.get_release_group_by_id(
release_group_id)
except mb_exceptions.NoDataFoundException:
flash.error(gettext("Can't find release group with that ID!"))
return redirect(
url_for('.spotify_list', release_group_id=release_group_id))
# Checking if release group is mapped to Spotify
spotify_mappings = mbspotify.mappings(str(release_group_id))
if spotify_uri not in spotify_mappings:
flash.error(gettext("This album is not mapped to Spotify yet!"))
return redirect(
url_for('.spotify_list', release_group_id=release_group_id))
if request.method == 'POST':
mbspotify.vote(release_group_id, spotify_uri, current_user.id)
flash.success(
gettext("Incorrect Spotify mapping has been reported. Thank you!"))
return redirect(
url_for('.spotify_list', release_group_id=release_group_id))
try:
album = spotify_api.get_album(spotify_id)
except ExternalServiceException:
flash.error(
gettext("You need to specify existing album from Spotify!"))
return redirect(
url_for('.spotify_list', release_group_id=release_group_id))
return render_template('mapping/report.html',
release_group=release_group,
spotify_album=album)
def spotify_confirm():
"""Confirmation page for adding new Spotify mapping."""
release_group_id = request.args.get('release_group_id')
if not release_group_id:
raise BadRequest("Didn't provide `release_group_id`!")
try:
release_group = mb_release_group.get_release_group_by_id(release_group_id)
except mb_exceptions.NoDataFoundException:
flash.error(gettext("Only existing release groups can be mapped to Spotify!"))
return redirect(url_for('search.index'))
spotify_ref = request.args.get('spotify_ref', default=None)
if not spotify_ref:
flash.error(gettext("You need to select an album from Spotify!"))
return redirect(url_for('.spotify_add', release_group_id=release_group_id))
try:
spotify_id = parse_spotify_id(spotify_ref)
except UnsupportedSpotifyReferenceTypeException:
flash.error(gettext("You need to specify a correct link to this album on Spotify!"))
return redirect(url_for('.spotify_add', release_group_id=release_group_id))
except Exception:
raise BadRequest("Could not parse Spotify ID!")
try:
album = spotify_api.get_album(spotify_id)
except ExternalServiceException:
flash.error(gettext("You need to specify existing album from Spotify!"))
return redirect(url_for('.spotify_add', release_group_id=release_group_id))
if request.method == 'POST':
# TODO(roman): Check values that are returned by add_mapping (also take a look at related JS).
res, error = mbspotify.add_mapping(release_group_id, 'spotify:album:%s' % spotify_id, current_user.id)
if res:
flash.success(gettext("Spotify mapping has been added!"))
else:
flash.error(gettext("Could not add Spotify mapping!"))
current_app.logger.error("Failed to create new Spotify mapping! Error: {}".format(error))
return redirect(url_for('.spotify_list', release_group_id=release_group_id))
return render_template('mapping/confirm.html', release_group=release_group, spotify_album=album)
def spotify_list(release_group_id):
"""This view lists all Spotify albums mapped to a specified release group."""
spotify_mappings = mbspotify.mappings(str(release_group_id))
# Converting Spotify URIs to IDs
spotify_ids = []
for mapping in spotify_mappings:
spotify_ids.append(mapping[14:])
if spotify_ids:
try:
spotify_albums = spotify_api.get_multiple_albums(spotify_ids)
except ExternalServiceException as e:
raise ServiceUnavailable(e)
else:
spotify_albums = {}
try:
release_group = mb_release_group.get_release_group_by_id(str(release_group_id))
except mb_exceptions.NoDataFoundException:
raise NotFound("Can't find release group with a specified ID.")
return render_template('mapping/list.html', spotify_albums=spotify_albums,
release_group=release_group)
def spotify_add():
release_group_id = request.args.get('release_group_id')
if not release_group_id:
return redirect(url_for('frontend.index'))
try:
release_group = mb_release_group.get_release_group_by_id(release_group_id)
except mb_exceptions.NoDataFoundException:
flash.error(gettext("Only existing release groups can be mapped to Spotify!"))
return redirect(url_for('search.index'))
page = int(request.args.get('page', default=1))
if page < 1:
return redirect(url_for('.spotify_add'))
limit = 16
offset = (page - 1) * limit
# Removing punctuation from the string
punctuation_map = dict((ord(char), None) for char in string.punctuation)
query = release_group['title'].translate(punctuation_map)
# Searching...
try:
response = spotify_api.search(query, item_types='album', limit=limit, offset=offset).get('albums')
except ExternalServiceException as e:
current_app.logger.error("Error while searching Spotify API: %s", str(e), exc_info=True)
raise ServiceUnavailable(e)
albums_ids = [x['id'] for x in response['items']]
try:
full_response = spotify_api.get_multiple_albums(albums_ids)
except ExternalServiceException as e:
current_app.logger.error("Error while getting albums from Spotify: %s", str(e), exc_info=True)
raise ServiceUnavailable(e)
search_results = [full_response[id] for id in albums_ids if id in full_response]
return render_template('mapping/spotify.html', release_group=release_group,
search_results=search_results, page=page, limit=limit,
count=response.get('total'))
def spotify_list(release_group_id):
"""This view lists all Spotify albums mapped to a specified release group."""
spotify_mappings = mbspotify.mappings(str(release_group_id))
# Converting Spotify URIs to IDs
spotify_ids = []
for mapping in spotify_mappings:
spotify_ids.append(mapping[14:])
if spotify_ids:
try:
spotify_albums = spotify_api.get_multiple_albums(spotify_ids)
except ExternalServiceException as e:
raise ServiceUnavailable(e)
else:
spotify_albums = {}
try:
release_group = mb_release_group.get_release_group_by_id(
str(release_group_id))
except mb_exceptions.NoDataFoundException:
raise NotFound("Can't find release group with a specified ID.")
return render_template('mapping/list.html',
spotify_albums=spotify_albums,
release_group=release_group)
