def test_languages(self):
db_review.create(
user_id=self.user.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796ece",
entity_type="release_group",
text="Testing",
is_draft=False,
license_id=self.license["id"],
language="en",
)
db_review.create(
user_id=self.user.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
text="Testing",
is_draft=False,
license_id=self.license["id"],
language="de",
)
reviews, count = db_review.list_reviews(language="de")
self.assertEqual(len(reviews), 1)
self.assertEqual(count, 1)
reviews, count = db_review.list_reviews(language="ru")
self.assertEqual(count, 0)
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_languages(self):
db_review.create(
user_id=self.user.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796ece",
entity_type="release_group",
text="Testing",
is_draft=False,
license_id=self.license["id"],
language="en",
)
db_review.create(
user_id=self.user.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
text="Testing",
is_draft=False,
license_id=self.license["id"],
language="de",
)
reviews, count = db_review.list_reviews(language="de")
self.assertEqual(len(reviews), 1)
self.assertEqual(count, 1)
reviews, count = db_review.list_reviews(language="ru")
self.assertEqual(count, 0)
def entity(id):
id = str(id)
try:
place = mb_place.get_place_by_id(id)
except mb_exceptions.NoDataFoundException:
raise NotFound(gettext("Sorry, we couldn't find a place with that MusicBrainz ID."))
if current_user.is_authenticated:
my_reviews, _ = db_review.list_reviews(
entity_id=place['id'],
entity_type='place',
user_id=current_user.id
)
my_review = my_reviews[0] if my_reviews else None
else:
my_review = None
rating_form = RatingEditForm(entity_id=id, entity_type='place')
rating_form.rating.data = my_review['rating'] if my_review else None
limit = int(request.args.get('limit', default=10))
offset = int(request.args.get('offset', default=0))
reviews, count = db_review.list_reviews(
entity_id=place['id'],
entity_type='place',
sort='popularity',
limit=limit,
offset=offset,
)
avg_rating = get_avg_rating(place['id'], "place")
return render_template('place/entity.html', id=place['id'], place=place, reviews=reviews,
rating_form=rating_form, my_review=my_review, limit=limit, offset=offset,
count=count, avg_rating=avg_rating, current_user=current_user)
def entity(id):
id = str(id)
try:
event = mb_event.get_event_by_id(id)
except mb_exceptions.NoDataFoundException:
raise NotFound(
gettext(
"Sorry, we couldn't find an event with that MusicBrainz ID."))
if 'url-rels' in event:
external_reviews = list(
filter(lambda rel: rel['type'] == 'review', event['url-rels']))
else:
external_reviews = []
if 'artist-rels' in event and event['artist-rels']:
artists_unique = []
for artist in event['artist-rels']:
if artist not in artists_unique:
artists_unique.append(artist)
artists_sorted = sorted(artists_unique, key=itemgetter('type'))
event['artists_grouped'] = groupby(artists_sorted, itemgetter('type'))
if current_user.is_authenticated:
my_reviews, _ = db_review.list_reviews(entity_id=event['id'],
entity_type='event',
user_id=current_user.id)
my_review = my_reviews[0] if my_reviews else None
else:
my_review = None
rating_form = RatingEditForm(entity_id=id, entity_type='event')
rating_form.rating.data = my_review['rating'] if my_review else None
limit = int(request.args.get('limit', default=10))
offset = int(request.args.get('offset', default=0))
reviews, count = db_review.list_reviews(entity_id=event['id'],
entity_type='event',
sort='popularity',
limit=limit,
offset=offset)
avg_rating = get_avg_rating(event['id'], "event")
return render_template('event/entity.html',
id=event['id'],
event=event,
reviews=reviews,
rating_form=rating_form,
my_review=my_review,
external_reviews=external_reviews,
limit=limit,
offset=offset,
count=count,
avg_rating=avg_rating,
current_user=current_user)
def test_review_deletion(self):
review = db_review.create(
user_id=self.user.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
text="Testing",
is_draft=False,
license_id=self.license["id"],
)
self.assertEqual(db_review.list_reviews()[1], 1)
db_review.delete(review["id"])
self.assertEqual(db_review.list_reviews()[1], 0)
def test_review_deletion(self):
review = db_review.create(
user_id=self.user.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
text="Testing",
is_draft=False,
license_id=self.license["id"],
)
self.assertEqual(db_review.list_reviews()[1], 1)
db_review.delete(review["id"])
self.assertEqual(db_review.list_reviews()[1], 0)
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 entity(id):
id = str(id)
try:
recording = mb_recording.get_recording_by_id(id)
except mb_exceptions.NoDataFoundException:
raise NotFound(
gettext(
"Sorry, we couldn't find a recording with that MusicBrainz ID."
))
if 'url-rels' in recording:
external_reviews = list(
filter(lambda rel: rel['type'] == 'review', recording['url-rels']))
else:
external_reviews = []
limit = int(request.args.get('limit', default=RECORDING_REVIEWS_LIMIT))
offset = int(request.args.get('offset', default=0))
if current_user.is_authenticated:
my_reviews, my_count = db_review.list_reviews(
entity_id=recording['id'],
entity_type='recording',
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=recording['id'],
entity_type='recording',
sort='popularity',
limit=limit,
offset=offset,
)
avg_rating = get_avg_rating(recording['id'], "recording")
rating_form = RatingEditForm(entity_id=id, entity_type='recording')
rating_form.rating.data = my_review['rating'] if my_review else None
return render_template('recording/entity.html',
id=recording['id'],
recording=recording,
reviews=reviews,
my_review=my_review,
external_reviews=external_reviews,
limit=limit,
offset=offset,
count=count,
avg_rating=avg_rating,
rating_form=rating_form,
current_user=current_user)
def entity(id):
id = str(id)
try:
work = mb_work.get_work_by_id(id)
except mb_exceptions.NoDataFoundException:
raise NotFound(gettext("Sorry, we couldn't find a work with that MusicBrainz ID."))
work_reviews_limit = WORK_REVIEWS_LIMIT
if request.args.get('reviews') == "all":
work_reviews_limit = None
if current_user.is_authenticated:
my_reviews, _ = db_review.list_reviews(
entity_id=work['id'],
entity_type='work',
user_id=current_user.id,
)
my_review = my_reviews[0] if my_reviews else None
else:
my_review = None
reviews_offset = 0
reviews, reviews_count = db_review.list_reviews(
entity_id=work['id'],
entity_type='work',
sort='popularity',
limit=work_reviews_limit,
offset=reviews_offset,
)
page = int(request.args.get('page', default=1))
if page < 1:
return redirect(url_for('.reviews'))
recording_rels = work['recording-rels']
recording_count = len(recording_rels)
recording_offset = (page - 1) * BROWSE_RECORDING_LIMIT
recording_rels = recording_rels[recording_offset:recording_offset + BROWSE_RECORDING_LIMIT]
avg_rating = get_avg_rating(work['id'], "work")
rating_form = RatingEditForm(entity_id=id, entity_type='work')
rating_form.rating.data = my_review['rating'] if my_review else None
return render_template('work/entity.html', id=work['id'], work=work, page=page,
reviews=reviews, my_review=my_review, reviews_limit=work_reviews_limit,
reviews_count=reviews_count, avg_rating=avg_rating, rating_form=rating_form,
recording_limit=BROWSE_RECORDING_LIMIT, recording_rels=recording_rels,
recording_count=recording_count, current_user=current_user)
def fetch_params():
is_draft = Parser.bool('json', 'is_draft', optional=True) or False
if is_draft:
REVIEW_TEXT_MIN_LENGTH = None
entity_id = Parser.uuid('json', 'entity_id')
entity_type = Parser.string('json',
'entity_type',
valid_values=ENTITY_TYPES)
text = Parser.string('json',
'text',
min=REVIEW_TEXT_MIN_LENGTH,
max=REVIEW_TEXT_MAX_LENGTH,
optional=True)
rating = Parser.int('json',
'rating',
min=REVIEW_RATING_MIN,
max=REVIEW_RATING_MAX,
optional=True)
license_choice = Parser.string('json', 'license_choice')
language = Parser.string(
'json', 'language', min=2, max=3, optional=True) or 'en'
if text is None and rating is None:
raise InvalidRequest(desc='Review must have either text or rating')
if language and language not in supported_languages:
raise InvalidRequest(desc='Unsupported language')
if db_review.list_reviews(user_id=user.id, entity_id=entity_id)[1]:
raise InvalidRequest(
desc='You have already published a review for this album')
return entity_id, entity_type, text, rating, license_choice, language, is_draft
def entity(id, rev=None):
review = get_review_or_404(id)
# Not showing review if it isn't published yet and not viewed by author.
if review["is_draft"] and not (current_user.is_authenticated
and current_user == review["user"]):
raise NotFound(gettext("Can't find a review with the specified ID."))
if review["is_hidden"]:
if not current_user.is_admin():
raise Forbidden(
gettext("Review has been hidden. "
"You need to be an administrator to view it."))
else:
flash.warn(gettext("Review has been hidden."))
spotify_mappings = None
soundcloud_url = None
if review["entity_type"] == 'release_group':
spotify_mappings = mbspotify.mappings(str(review["entity_id"]))
soundcloud_url = soundcloud.get_url(str(review["entity_id"]))
count = db_revision.get_count(id)
if not rev:
rev = count
if rev < count:
flash.info(
gettext(
'You are viewing an old revision, the review has been updated since then.'
))
elif rev > count:
raise NotFound(
gettext("The revision you are looking for does not exist."))
revision = db_revision.get(id, offset=count - rev)[0]
if not review[
"is_draft"] and current_user.is_authenticated: # if user is logged in, get their vote for this review
try:
vote = db_vote.get(user_id=current_user.id,
revision_id=revision['id'])
except db_exceptions.NoDataFoundException:
vote = None
else: # otherwise set vote to None, its value will not be used
vote = None
if revision["text"] is None:
review["text_html"] = None
else:
review["text_html"] = markdown(revision['text'], safe_mode="escape")
user_all_reviews, review_count = db_review.list_reviews( # pylint: disable=unused-variable
user_id=review["user_id"],
sort="random",
exclude=[review["id"]],
)
other_reviews = user_all_reviews[:3]
avg_rating = get_avg_rating(review["entity_id"], review["entity_type"])
return render_template('review/entity/%s.html' % review["entity_type"],
review=review,
spotify_mappings=spotify_mappings,
soundcloud_url=soundcloud_url,
vote=vote,
other_reviews=other_reviews,
avg_rating=avg_rating)
def reviews(user_id):
user_id = str(user_id)
if current_user.is_authenticated and current_user.id == user_id:
user = current_user
else:
user = db_users.get_by_id(user_id)
if not user:
raise NotFound(
"Can't find a user with ID: {user_id}".format(user_id=user_id))
user = User(user)
page = int(request.args.get('page', default=1))
if page < 1:
return redirect(url_for('.reviews'))
limit = 12
offset = (page - 1) * limit
reviews, count = db_review.list_reviews(
user_id=user_id,
sort='published_on',
limit=limit,
offset=offset,
inc_hidden=current_user.is_admin(),
inc_drafts=current_user.is_authenticated
and current_user.id == user_id)
return render_template('user/reviews.html',
section='reviews',
user=user,
reviews=reviews,
page=page,
limit=limit,
count=count)
def test_review_creation(self):
review = db_review.create(
user_id=self.user.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
text="Testing",
rating=5,
is_draft=False,
license_id=self.license["id"],
)
reviews, count = db_review.list_reviews()
self.assertEqual(count, 1)
self.assertEqual(reviews[0]["id"], review["id"])
self.assertEqual(reviews[0]["entity_id"], review["entity_id"])
self.assertEqual(reviews[0]["license_id"], review["license_id"])
self.assertEqual(reviews[0]["rating"], review["rating"])
with self.assertRaises(db_exceptions.BadDataException):
db_review.create(
user_id=self.user_2.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
is_draft=False,
license_id=self.license["id"],
)
def browse():
entity_type = request.args.get('entity_type', default=None)
if entity_type == 'all':
entity_type = None
page = int(request.args.get('page', default=1))
if page < 1:
return redirect(url_for('.browse'))
limit = 3 * 9 # 9 rows
offset = (page - 1) * limit
reviews, count = db_review.list_reviews(sort='created',
limit=limit,
offset=offset,
entity_type=entity_type)
if not reviews:
if page - 1 > count / limit:
return redirect(
url_for('review.browse', page=int(ceil(count / limit))))
else:
if not entity_type:
raise NotFound(gettext("No reviews to display."))
# Loading info about entities for reviews
entities = [(str(review["entity_id"]), review["entity_type"])
for review in reviews]
entities_info = get_multiple_entities(entities)
return render_template('review/browse.html',
reviews=reviews,
entities=entities_info,
page=page,
limit=limit,
count=count,
entity_type=entity_type)
def test_review_creation(self):
review = db_review.create(
user_id=self.user.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
text="Testing",
rating=5,
is_draft=False,
license_id=self.license["id"],
)
reviews, count = db_review.list_reviews()
self.assertEqual(count, 1)
self.assertEqual(reviews[0]["id"], review["id"])
self.assertEqual(reviews[0]["entity_id"], review["entity_id"])
self.assertEqual(reviews[0]["license_id"], review["license_id"])
self.assertEqual(reviews[0]["rating"], review["rating"])
with self.assertRaises(db_exceptions.BadDataException):
db_review.create(
user_id=self.user_2.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
is_draft=False,
license_id=self.license["id"],
)
def entity(id):
id = str(id)
try:
label = mb_label.get_label_by_id(id)
except mb_exceptions.NoDataFoundException:
raise NotFound(
gettext(
"Sorry, we couldn't find a label with that MusicBrainz ID."))
label_reviews_limit = LABEL_REVIEWS_LIMIT
if request.args.get('reviews') == "all":
label_reviews_limit = None
if current_user.is_authenticated:
my_reviews, my_count = db_review.list_reviews(
entity_id=label['id'],
entity_type='label',
user_id=current_user.id,
)
my_review = my_reviews[0] if my_count else None
else:
my_review = None
reviews_offset = 0
reviews, reviews_count = db_review.list_reviews(
entity_id=label['id'],
entity_type='label',
sort='popularity',
limit=label_reviews_limit,
offset=reviews_offset,
)
avg_rating = get_avg_rating(label['id'], "label")
rating_form = RatingEditForm(entity_id=id, entity_type='label')
rating_form.rating.data = my_review['rating'] if my_review else None
return render_template('label/entity.html',
id=label['id'],
label=label,
reviews=reviews,
my_review=my_review,
reviews_limit=label_reviews_limit,
reviews_count=reviews_count,
avg_rating=avg_rating,
rating_form=rating_form,
current_user=current_user)
def entity(id):
id = str(id)
try:
event = mb_event.get_event_by_id(id)
except mb_exceptions.NoDataFoundException:
raise NotFound(gettext("Sorry, we couldn't find an event with that MusicBrainz ID."))
if 'url-rels' in event:
external_reviews = list(filter(lambda rel: rel['type'] == 'review', event['url-rels']))
else:
external_reviews = []
if 'artist-rels' in event and event['artist-rels']:
artists_sorted = sorted(event['artist-rels'], key=itemgetter('type'))
event['artists_grouped'] = groupby(artists_sorted, itemgetter('type'))
if current_user.is_authenticated:
my_reviews, my_count = db_review.list_reviews(
entity_id=event['id'],
entity_type='event',
user_id=current_user.id
)
my_review = my_reviews[0] if my_count else None
else:
my_review = None
rating_form = RatingEditForm(entity_id=id, entity_type='event')
rating_form.rating.data = my_review['rating'] if my_review else None
limit = int(request.args.get('limit', default=10))
offset = int(request.args.get('offset', default=0))
reviews, count = db_review.list_reviews(
entity_id=event['id'],
entity_type='event',
sort='popularity',
limit=limit,
offset=offset
)
avg_rating = get_avg_rating(event['id'], "event")
return render_template('event/entity.html', id=event['id'], event=event, reviews=reviews,
rating_form=rating_form, my_review=my_review, external_reviews=external_reviews,
limit=limit, offset=offset, count=count, avg_rating=avg_rating, current_user=current_user)
def entity(id):
id = str(id)
try:
event = mb_event.get_event_by_id(id)
except mb_exceptions.NoDataFoundException:
raise NotFound(
gettext(
"Sorry, we couldn't find a event with that MusicBrainz ID."))
if 'artist-rels' in event and event['artist-rels']:
artists_sorted = sorted(event['artist-rels'], key=itemgetter('type'))
event['artists_grouped'] = groupby(artists_sorted, itemgetter('type'))
if current_user.is_authenticated:
my_reviews, my_count = db_review.list_reviews(entity_id=event['id'],
entity_type='event',
user_id=current_user.id)
if my_count != 0:
my_review = my_reviews[0]
else:
my_review = None
else:
my_review = None
limit = int(request.args.get('limit', default=10))
offset = int(request.args.get('offset', default=0))
reviews, count = db_review.list_reviews(entity_id=event['id'],
entity_type='event',
sort='popularity',
limit=limit,
offset=offset)
avg_rating = get_avg_rating(event['id'], "event")
return render_template('event/entity.html',
id=event['id'],
event=event,
reviews=reviews,
my_review=my_review,
limit=limit,
offset=offset,
count=count,
avg_rating=avg_rating)
def entity(mbid):
"""Artist page.
Displays release groups (split up into several sections depending on their
type), artist information (type, members/member of, external links).
"""
try:
artist = mb_artist.get_artist_by_id(str(mbid))
except mb_exceptions.NoDataFoundException:
raise NotFound(
gettext(
"Sorry, we couldn't find an artist with that MusicBrainz ID."))
# Note that some artists might not have a list of members because they are not a band
band_members = _get_band_members(artist)
release_type = request.args.get('release_type', default='album')
if release_type not in ['album', 'single', 'ep', 'broadcast',
'other']: # supported release types
raise BadRequest("Unsupported release type.")
page = int(request.args.get('page', default=1))
if page < 1:
return redirect(url_for('.reviews'))
limit = 20
offset = (page - 1) * limit
release_groups, count = mb_release_group.browse_release_groups(
artist_id=artist['id'],
release_types=[release_type],
limit=limit,
offset=offset,
)
for release_group in release_groups:
# TODO(roman): Count reviews instead of fetching them.
reviews, review_count = db_review.list_reviews( # pylint: disable=unused-variable
entity_id=release_group['id'],
entity_type='release_group',
sort='published_on',
limit=1,
)
release_group['review_count'] = review_count
return render_template(
'artist/entity.html',
id=artist['id'],
artist=artist,
release_type=release_type,
release_groups=release_groups,
page=page,
limit=limit,
count=count,
band_members=band_members,
)
def entity(mbid):
"""Artist page.
Displays release groups (split up into several sections depending on their
type), artist information (type, members/member of, external links).
"""
try:
artist = mb_artist.get_artist_by_id(str(mbid))
except mb_exceptions.NoDataFoundException:
raise NotFound(gettext("Sorry, we couldn't find an artist with that MusicBrainz ID."))
# Note that some artists might not have a list of members because they are not a band
band_members = _get_band_members(artist)
release_type = request.args.get('release_type', default='album')
if release_type not in ['album', 'single', 'ep', 'broadcast', 'other']: # supported release types
raise BadRequest("Unsupported release type.")
page = int(request.args.get('page', default=1))
if page < 1:
return redirect(url_for('.reviews'))
limit = 20
offset = (page - 1) * limit
release_groups, count = mb_release_group.browse_release_groups(
artist_id=artist['id'],
release_types=[release_type],
limit=limit,
offset=offset,
)
for release_group in release_groups:
# TODO(roman): Count reviews instead of fetching them.
reviews, review_count = db_review.list_reviews( # pylint: disable=unused-variable
entity_id=release_group['id'],
entity_type='release_group',
sort='published_on', limit=1,
)
release_group['review_count'] = review_count
return render_template(
'artist/entity.html',
id=artist['id'],
artist=artist,
release_type=release_type,
release_groups=release_groups,
page=page,
limit=limit,
count=count,
band_members=band_members,
)
def json(location, rotate=False):
"""Create JSON dumps with all reviews.
This command will create an archive for each license available on CB.
Archives will be put into a specified directory (default is *dump*).
"""
create_path(location)
current_app.json_encoder = DumpJSONEncoder
print("Creating new archives...")
for license in db_license.list_licenses():
safe_name = slugify(license["id"])
with tarfile.open(os.path.join(location, "critiquebrainz-%s-%s-json.tar.bz2" %
(datetime.today().strftime('%Y%m%d'), safe_name)), "w:bz2") as tar:
temp_dir = tempfile.mkdtemp()
license_dir = os.path.join(temp_dir, safe_name)
create_path(license_dir)
# Finding entities that have reviews with current license
entities = db_review.distinct_entities()
for entity in entities:
entity = str(entity)
# Creating directory structure and dumping reviews
dir_part = os.path.join(entity[0:1], entity[0:2])
reviews = db_review.list_reviews(entity_id=entity, license_id=license["id"], limit=None)[0]
if reviews:
rg_dir = '%s/%s' % (license_dir, dir_part)
create_path(rg_dir)
f = open('%s/%s.json' % (rg_dir, entity), 'w+')
f.write(jsonify(reviews=[db_review.to_dict(r) for r in reviews]).data.decode("utf-8"))
f.close()
tar.add(license_dir, arcname='reviews')
# Copying legal text
tar.add(os.path.join("critiquebrainz", "data", "licenses", safe_name + ".txt"), arcname='COPYING')
print(" + %s/critiquebrainz-%s-%s-json.tar.bz2" % (location, datetime.today().strftime('%Y%m%d'), safe_name))
shutil.rmtree(temp_dir) # Cleanup
if rotate:
print("Removing old sets of archives (except two latest)...")
remove_old_archives(location, "critiquebrainz-[0-9]+-[-\w]+-json.tar.bz2",
is_dir=False, sort_key=os.path.getmtime)
print("Done!")
def index():
# Popular reviews
popular_reviews = db_review.get_popular(6)
for review in popular_reviews:
# Preparing text for preview
preview = markdown(review['text'], safe_mode="escape")
review['preview'] = ''.join(BeautifulSoup(preview, "html.parser").findAll(text=True))
# Recent reviews
recent_reviews, _ = db_review.list_reviews(sort='created', limit=9)
# Statistics
review_count = format_number(db_review.get_count(is_draft=False))
user_count = format_number(db_users.total_count())
return render_template('index/index.html', popular_reviews=popular_reviews, recent_reviews=recent_reviews,
reviews_total=review_count, users_total=user_count)
def index():
# Popular reviews
popular_reviews = db_review.get_popular(6)
for review in popular_reviews:
# Preparing text for preview
preview = markdown(review['text'], safe_mode="escape")
review['preview'] = ''.join(BeautifulSoup(preview, "html.parser").findAll(text=True))
# Recent reviews
recent_reviews, _ = db_review.list_reviews(sort='published_on', limit=9)
# Statistics
review_count = format_number(db_review.get_count(is_draft=False))
user_count = format_number(db_users.total_count())
return render_template('index/index.html', popular_reviews=popular_reviews, recent_reviews=recent_reviews,
reviews_total=review_count, users_total=user_count)
def fetch_params():
is_draft = Parser.bool('json', 'is_draft', optional=True) or False
if is_draft:
REVIEW_TEXT_MIN_LENGTH = None
entity_id = Parser.uuid('json', 'entity_id')
entity_type = Parser.string('json', 'entity_type', valid_values=ENTITY_TYPES)
text = Parser.string('json', 'text', min=REVIEW_TEXT_MIN_LENGTH, max=REVIEW_TEXT_MAX_LENGTH, optional=True)
rating = Parser.int('json', 'rating', min=REVIEW_RATING_MIN, max=REVIEW_RATING_MAX, optional=True)
license_choice = Parser.string('json', 'license_choice')
language = Parser.string('json', 'language', min=2, max=3, optional=True) or 'en'
if text is None and rating is None:
raise InvalidRequest(desc='Review must have either text or rating')
if language and language not in supported_languages:
raise InvalidRequest(desc='Unsupported language')
if db_review.list_reviews(user_id=user.id, entity_id=entity_id)[1]:
raise InvalidRequest(desc='You have already published a review for this album')
return entity_id, entity_type, text, rating, license_choice, language, is_draft
def rate():
form = RatingEditForm()
if form.validate_on_submit():
if current_user.is_blocked:
flash.error(
gettext("You are not allowed to rate any entity because your "
"account has been blocked by a moderator."))
return redirect(
url_for('{}.entity'.format(form.entity_type.data),
id=form.entity_id.data))
reviews, review_count = db_review.list_reviews(
entity_id=form.entity_id.data,
entity_type=form.entity_type.data,
user_id=current_user.id,
)
review = reviews[0] if review_count else None
if not review and form.rating.data is None:
raise BadRequest(
"Cannot create a review with no rating and no text!")
if not review and form.rating.data is not None:
db_review.create(
user_id=current_user.id,
entity_id=form.entity_id.data,
entity_type=form.entity_type.data,
rating=form.rating.data,
is_draft=False,
)
elif review and review['text'] is None and form.rating.data is None:
db_review.delete(review['id'])
elif review and review['rating'] != form.rating.data:
db_review.update(
review_id=review['id'],
drafted=review['is_draft'],
text=review['text'],
rating=form.rating.data,
)
# TODO(code-master5): Make this message specify the entity
flash.success("We have updated your rating for this entity!")
else:
flash.error("Error! Could not update the rating...")
return redirect(
url_for('{}.entity'.format(form.entity_type.data),
id=form.entity_id.data))
def reviews(user_id):
user_id = str(user_id)
if current_user.is_authenticated and current_user.id == user_id:
user = current_user
else:
user = db_users.get_by_id(user_id)
if not user:
raise NotFound("Can't find a user with ID: {user_id}".format(user_id=user_id))
user = User(user)
page = int(request.args.get('page', default=1))
if page < 1:
return redirect(url_for('.reviews'))
limit = 12
offset = (page - 1) * limit
reviews, count = db_review.list_reviews(user_id=user_id, sort='published_on', limit=limit, offset=offset,
inc_hidden=current_user.is_admin(),
inc_drafts=current_user.is_authenticated and current_user.id == user_id)
return render_template('user/reviews.html', section='reviews', user=user,
reviews=reviews, page=page, limit=limit, count=count)
def rate():
form = RatingEditForm()
if form.validate_on_submit():
if current_user.is_blocked:
flash.error(gettext("You are not allowed to rate any entity because your "
"account has been blocked by a moderator."))
return redirect(url_for('{}.entity'.format(form.entity_type.data), id=form.entity_id.data))
reviews, review_count = db_review.list_reviews(
entity_id=form.entity_id.data,
entity_type=form.entity_type.data,
user_id=current_user.id,
)
review = reviews[0] if review_count else None
if not review and form.rating.data is None:
raise BadRequest("Cannot create a review with no rating and no text!")
if not review and form.rating.data is not None:
db_review.create(
user_id=current_user.id,
entity_id=form.entity_id.data,
entity_type=form.entity_type.data,
rating=form.rating.data,
is_draft=False,
)
elif review and review['text'] is None and form.rating.data is None:
db_review.delete(review['id'])
elif review and review['rating'] != form.rating.data:
db_review.update(
review_id=review['id'],
drafted=review['is_draft'],
text=review['text'],
rating=form.rating.data,
)
# TODO(code-master5): Make this message specify the entity
flash.success("We have updated your rating for this entity!")
else:
flash.error("Error! Could not update the rating...")
return redirect(url_for('{}.entity'.format(form.entity_type.data), id=form.entity_id.data))
def test_artist_rating(self):
self.temporary_login(self.reviewer)
test_entity_id = 'f59c5520-5f46-4d2c-b2c4-822eabf53419'
payload = {
'entity_id': test_entity_id,
'entity_type': 'artist',
'rating': 4
}
response = self.client.post(url_for('rate.rate'), data=payload)
self.assertRedirects(response, '/artist/{}'.format(test_entity_id))
reviews, review_count = db_review.list_reviews(
entity_id=test_entity_id,
entity_type='artist',
user_id=self.reviewer.id)
self.assertEqual(review_count, 1)
self.assertEqual(reviews[0]['rating'], 4)
response = self.client.get('/artist/{}'.format(test_entity_id))
self.assert200(response)
self.assertIn('We have updated your rating for this entity!',
str(response.data))
def test_list_reviews(self):
reviews, count = db_review.list_reviews()
self.assertEqual(count, 0)
self.assertEqual(len(reviews), 0)
review = db_review.create(
user_id=self.user.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
text="Awesome",
rating=5,
is_draft=False,
license_id=self.license["id"],
)
reviews, count = db_review.list_reviews()
self.assertEqual(count, 1)
self.assertEqual(len(reviews), 1)
self.assertEqual(reviews[0]["text"], "Awesome")
self.assertEqual(reviews[0]["rating"], 5)
db_review.update(
review_id=review["id"],
drafted=review["is_draft"],
text="Beautiful!",
rating=4,
)
reviews, count = db_review.list_reviews()
self.assertEqual(count, 1)
self.assertEqual(len(reviews), 1)
self.assertEqual(reviews[0]["text"], "Beautiful!")
self.assertEqual(reviews[0]["rating"], 4)
reviews, count = db_review.list_reviews(sort="popularity")
self.assertEqual(count, 1)
self.assertEqual(len(reviews), 1)
reviews, count = db_review.list_reviews(sort="published_on")
self.assertEqual(count, 1)
self.assertEqual(len(reviews), 1)
reviews, count = db_review.list_reviews(sort="random")
self.assertEqual(count, 1)
self.assertEqual(len(reviews), 1)
def test_list_reviews(self):
reviews, count = db_review.list_reviews()
self.assertEqual(count, 0)
self.assertEqual(len(reviews), 0)
review = db_review.create(
user_id=self.user.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
text="Awesome",
rating=5,
is_draft=False,
license_id=self.license["id"],
)
reviews, count = db_review.list_reviews()
self.assertEqual(count, 1)
self.assertEqual(len(reviews), 1)
self.assertEqual(reviews[0]["text"], "Awesome")
self.assertEqual(reviews[0]["rating"], 5)
db_review.update(
review_id=review["id"],
drafted=review["is_draft"],
text="Beautiful!",
rating=4,
)
reviews, count = db_review.list_reviews()
self.assertEqual(count, 1)
self.assertEqual(len(reviews), 1)
self.assertEqual(reviews[0]["text"], "Beautiful!")
self.assertEqual(reviews[0]["rating"], 4)
reviews, count = db_review.list_reviews(sort="popularity")
self.assertEqual(count, 1)
self.assertEqual(len(reviews), 1)
reviews, count = db_review.list_reviews(sort="published_on")
self.assertEqual(count, 1)
self.assertEqual(len(reviews), 1)
reviews, count = db_review.list_reviews(sort="random")
self.assertEqual(count, 1)
self.assertEqual(len(reviews), 1)
def test_rate(self):
self.temporary_login(self.reviewer)
# Test for first time rating (no review exists)
payload = {
'entity_id': self.test_entity['id'],
'entity_type': 'release_group',
'rating': 4
}
response = self.client.post(
url_for('rate.rate'),
data=payload
)
self.assertRedirects(response, '/release-group/{}'.format(self.test_entity['id']))
reviews, review_count = db_review.list_reviews(
entity_id=self.test_entity['id'],
entity_type='release_group',
user_id=self.reviewer.id
)
# Test that the rate request created a review
self.assertEqual(review_count, 1)
review = reviews[0]
self.assertEqual(review['text'], None)
self.assertEqual(review['rating'], 4)
response = self.client.get('/release-group/{}'.format(self.test_entity['id']))
self.assert200(response)
self.assertIn('We have updated your rating for this entity!', str(response.data))
# Test after rating is cleared for review with NO text
payload = {
'entity_id': self.test_entity['id'],
'entity_type': 'release_group',
'rating': None
}
response = self.client.post(
url_for('rate.rate'),
data=payload
)
reviews, review_count = db_review.list_reviews(
entity_id=self.test_entity['id'],
entity_type='release_group',
user_id=self.reviewer.id
)
# Test that the clear rating request results in deletion of review (because review-text was None)
self.assertEqual(review_count, 0)
# Test after rating is cleared for review with some text
self.review = db_review.create(
user_id=self.reviewer.id,
entity_id=self.test_entity['id'],
entity_type="release_group",
text="Test Review.",
rating=4,
is_draft=False,
license_id=self.license["id"],
)
payload = {
'entity_id': self.test_entity['id'],
'entity_type': 'release_group',
'rating': None
}
response = self.client.post(
url_for('rate.rate'),
data=payload
)
reviews, review_count = db_review.list_reviews(
entity_id=self.test_entity['id'],
entity_type='release_group',
user_id=self.reviewer.id
)
# Test that the clear rating request doesn't delete review (because review-text was not None)
self.assertEqual(review_count, 1)
review = reviews[0]
self.assertEqual(review['rating'], None)
def test_update(self):
review = db_review.create(
user_id=self.user.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
text="Testing",
rating=5,
is_draft=True,
license_id=self.license["id"],
)
another_license = db_license.create(
id="License-2",
full_name="Another License",
)
# Update review to only rating
db_review.update(
review_id=review["id"],
drafted=review["is_draft"],
rating=4,
is_draft=False,
license_id=another_license["id"],
language="es",
)
# Checking if contents are updated
retrieved_review = db_review.list_reviews()[0][0]
self.assertEqual(retrieved_review["text"], None)
self.assertEqual(retrieved_review["rating"], 4)
self.assertFalse(retrieved_review["is_draft"])
self.assertEqual(retrieved_review["license_id"], another_license["id"])
self.assertEqual(retrieved_review["language"], "es")
# Update review to only text
db_review.update(
review_id=review["id"],
drafted=review["is_draft"],
text="Testing update",
is_draft=False,
license_id=another_license["id"],
language="es",
)
# Checking if contents are updated
retrieved_review = db_review.list_reviews()[0][0]
self.assertEqual(retrieved_review["text"], "Testing update")
self.assertEqual(retrieved_review["rating"], None)
# Updating should create a new revision.
revisions = db_revision.get(retrieved_review["id"], limit=None)
self.assertEqual(len(revisions), 3)
self.assertEqual(revisions[0]["timestamp"], retrieved_review["last_revision"]["timestamp"])
self.assertEqual(revisions[0]["text"], retrieved_review["text"])
self.assertEqual(revisions[0]["rating"], retrieved_review["rating"])
# Checking things that shouldn't be allowed
with self.assertRaises(db_exceptions.BadDataException):
db_review.update(
review_id=retrieved_review["id"],
drafted=retrieved_review["is_draft"],
text="Sucks!",
license_id=self.license["id"],
)
review = db_review.get_by_id(review["id"])
with self.assertRaises(db_exceptions.BadDataException):
db_review.update(
review_id=review["id"],
drafted=review["is_draft"],
text="Sucks!",
is_draft=True,
)
def review_list_handler():
"""Get list of reviews.
**Request Example:**
.. code-block:: bash
$ curl "https://critiquebrainz.org/ws/1/review/?limit=1&offset=50" \\
-X GET
**Response Example:**
.. code-block:: json
{
"count": 9197,
"limit": 1,
"offset": 50,
"reviews": [
{
"created": "Fri, 16 May 2008 00:00:00 GMT",
"edits": 0,
"entity_id": "09259937-6477-3959-8b10-af1cbaea8e6e",
"entity_type": "release_group",
"id": "c807d0b4-0dd0-43fe-a7c4-d29bb61f389e",
"language": "en",
"last_updated": "Fri, 16 May 2008 00:00:00 GMT",
"license": {
"full_name": "Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported",
"id": "CC BY-NC-SA 3.0",
"info_url": "https://creativecommons.org/licenses/by-nc-sa/3.0/"
},
"popularity": 0,
"source": "BBC",
"source_url": "http://www.bbc.co.uk/music/reviews/vh54",
"text": "TEXT CONTENT OF REVIEW",
"rating": 5,
"user": {
"created": "Wed, 07 May 2014 16:20:47 GMT",
"display_name": "Jenny Nelson",
"id": "3bf3fe0c-6db2-4746-bcf1-f39912113852",
"karma": 0,
"user_type": "Noob"
},
"votes": {
"positive": 0,
"negative": 0
}
}
]
}
:json uuid entity_id: UUID of the release group that is being reviewed
:json string entity_type: One of the supported reviewable entities. 'release_group' or 'event' etc. **(optional)**
:query user_id: user's UUID **(optional)**
:query sort: ``popularity`` or ``published_on`` **(optional)**
:query limit: results limit, min is 0, max is 50, default is 50 **(optional)**
:query offset: result offset, default is 0 **(optional)**
:query language: language code (ISO 639-1) **(optional)**
:resheader Content-Type: *application/json*
"""
# TODO: This checking is added to keep old clients working and needs to be removed.
release_group = Parser.uuid('uri', 'release_group', optional=True)
if release_group:
entity_id = release_group
entity_type = 'release_group'
else:
entity_id = Parser.uuid('uri', 'entity_id', optional=True)
entity_type = Parser.string('uri',
'entity_type',
valid_values=ENTITY_TYPES,
optional=True)
user_id = Parser.uuid('uri', 'user_id', optional=True)
sort = Parser.string(
'uri',
'sort',
valid_values=['popularity', 'published_on', 'rating', 'created'],
optional=True)
# "rating" and "created" sort values are deprecated and but allowed here for backward compatibility
if sort == 'created':
sort = 'published_on'
if sort == 'rating':
sort = 'popularity'
limit = Parser.int('uri', 'limit', min=1, max=50, optional=True) or 50
offset = Parser.int('uri', 'offset', optional=True) or 0
language = Parser.string('uri', 'language', min=2, max=3, optional=True)
if language and language not in supported_languages:
raise InvalidRequest(desc='Unsupported language')
# TODO(roman): Ideally caching logic should live inside the model. Otherwise it
# becomes hard to track all this stuff.
cache_key = cache.gen_key('list', entity_id, user_id, sort, limit, offset,
language)
cached_result = cache.get(cache_key, REVIEW_CACHE_NAMESPACE)
if cached_result:
reviews = cached_result['reviews']
count = cached_result['count']
else:
reviews, count = db_review.list_reviews(
entity_id=entity_id,
entity_type=entity_type,
user_id=user_id,
sort=sort,
limit=limit,
offset=offset,
language=language,
)
reviews = [db_review.to_dict(p) for p in reviews]
cache.set(cache_key, {
'reviews': reviews,
'count': count,
},
namespace=REVIEW_CACHE_NAMESPACE)
return jsonify(limit=limit, offset=offset, count=count, reviews=reviews)
def test_update(self):
review = db_review.create(
user_id=self.user.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
text="Testing",
rating=5,
is_draft=True,
license_id=self.license["id"],
)
another_license = db_license.create(
id="License-2",
full_name="Another License",
)
# Update review to only rating
db_review.update(
review_id=review["id"],
drafted=review["is_draft"],
rating=4,
is_draft=False,
license_id=another_license["id"],
language="es",
)
# Checking if contents are updated
retrieved_review = db_review.list_reviews()[0][0]
self.assertEqual(retrieved_review["text"], None)
self.assertEqual(retrieved_review["rating"], 4)
self.assertFalse(retrieved_review["is_draft"])
self.assertEqual(retrieved_review["license_id"], another_license["id"])
self.assertEqual(retrieved_review["language"], "es")
# Update review to only text
db_review.update(
review_id=review["id"],
drafted=review["is_draft"],
text="Testing update",
is_draft=False,
license_id=another_license["id"],
language="es",
)
# Checking if contents are updated
retrieved_review = db_review.list_reviews()[0][0]
self.assertEqual(retrieved_review["text"], "Testing update")
self.assertEqual(retrieved_review["rating"], None)
# Updating should create a new revision.
revisions = db_revision.get(retrieved_review["id"], limit=None)
self.assertEqual(len(revisions), 3)
self.assertEqual(revisions[0]["timestamp"],
retrieved_review["last_revision"]["timestamp"])
self.assertEqual(revisions[0]["text"], retrieved_review["text"])
self.assertEqual(revisions[0]["rating"], retrieved_review["rating"])
# Checking things that shouldn't be allowed
with self.assertRaises(db_exceptions.BadDataException):
db_review.update(
review_id=retrieved_review["id"],
drafted=retrieved_review["is_draft"],
text="Sucks!",
license_id=self.license["id"],
)
review = db_review.get_by_id(review["id"])
with self.assertRaises(db_exceptions.BadDataException):
db_review.update(
review_id=review["id"],
drafted=review["is_draft"],
text="Sucks!",
is_draft=True,
)
flash.info(gettext("Please choose an entity to review."))
return redirect(url_for('search.selector', next=url_for('.create')))
if entity_type not in ENTITY_TYPES:
raise BadRequest("You can't write reviews about this type of entity.")
if current_user.is_blocked:
flash.error(
gettext("You are not allowed to write new reviews because your "
"account has been blocked by a moderator."))
return redirect(url_for('user.reviews', user_id=current_user.id))
# Checking if the user already wrote a review for this entity
reviews, count = db_review.list_reviews(user_id=current_user.id,
entity_id=entity_id,
inc_drafts=True,
inc_hidden=True)
review = reviews[0] if count != 0 else None
if review:
if review['is_draft']:
return redirect(url_for('review.edit', id=review['id']))
elif review['is_hidden']:
return redirect(url_for('review.entity', id=review['id']))
else:
flash.error(
gettext("You have already published a review for this entity"))
return redirect(url_for('review.entity', id=review["id"]))
if current_user.is_review_limit_exceeded:
flash.error(
def review_list_handler():
"""Get list of reviews.
**Request Example:**
.. code-block:: bash
$ curl "https://critiquebrainz.org/ws/1/review/?limit=1&offset=50" \\
-X GET
**Response Example:**
.. code-block:: json
{
"count": 9197,
"limit": 1,
"offset": 50,
"reviews": [
{
"created": "Fri, 16 May 2008 00:00:00 GMT",
"edits": 0,
"entity_id": "09259937-6477-3959-8b10-af1cbaea8e6e",
"entity_type": "release_group",
"id": "c807d0b4-0dd0-43fe-a7c4-d29bb61f389e",
"language": "en",
"last_updated": "Fri, 16 May 2008 00:00:00 GMT",
"license": {
"full_name": "Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported",
"id": "CC BY-NC-SA 3.0",
"info_url": "https://creativecommons.org/licenses/by-nc-sa/3.0/"
},
"popularity": 0,
"source": "BBC",
"source_url": "http://www.bbc.co.uk/music/reviews/vh54",
"text": "TEXT CONTENT OF REVIEW",
"rating": 5,
"user": {
"created": "Wed, 07 May 2014 16:20:47 GMT",
"display_name": "Jenny Nelson",
"id": "3bf3fe0c-6db2-4746-bcf1-f39912113852",
"karma": 0,
"user_type": "Noob"
},
"votes": {
"positive": 0,
"negative": 0
}
}
]
}
:json uuid entity_id: UUID of the release group that is being reviewed
:json string entity_type: One of the supported reviewable entities. 'release_group' or 'event' etc. **(optional)**
:query user_id: user's UUID **(optional)**
:query sort: ``popularity`` or ``published_on`` **(optional)**
:query limit: results limit, min is 0, max is 50, default is 50 **(optional)**
:query offset: result offset, default is 0 **(optional)**
:query language: language code (ISO 639-1) **(optional)**
:resheader Content-Type: *application/json*
"""
# TODO: This checking is added to keep old clients working and needs to be removed.
release_group = Parser.uuid('uri', 'release_group', optional=True)
if release_group:
entity_id = release_group
entity_type = 'release_group'
else:
entity_id = Parser.uuid('uri', 'entity_id', optional=True)
entity_type = Parser.string('uri', 'entity_type', valid_values=ENTITY_TYPES, optional=True)
user_id = Parser.uuid('uri', 'user_id', optional=True)
# TODO: "rating" sort value is deprecated and needs to be removed.
sort = Parser.string('uri', 'sort', valid_values=['popularity', 'published_on', 'rating'], optional=True)
if sort == 'rating':
sort = 'popularity'
limit = Parser.int('uri', 'limit', min=1, max=50, optional=True) or 50
offset = Parser.int('uri', 'offset', optional=True) or 0
language = Parser.string('uri', 'language', min=2, max=3, optional=True)
if language and language not in supported_languages:
raise InvalidRequest(desc='Unsupported language')
# TODO(roman): Ideally caching logic should live inside the model. Otherwise it
# becomes hard to track all this stuff.
cache_key = cache.gen_key('list', entity_id, user_id, sort, limit, offset, language)
cached_result = cache.get(cache_key, REVIEW_CACHE_NAMESPACE)
if cached_result:
reviews = cached_result['reviews']
count = cached_result['count']
else:
reviews, count = db_review.list_reviews(
entity_id=entity_id,
entity_type=entity_type,
user_id=user_id,
sort=sort,
limit=limit,
offset=offset,
language=language,
)
reviews = [db_review.to_dict(p) for p in reviews]
cache.set(cache_key, {
'reviews': reviews,
'count': count,
}, namespace=REVIEW_CACHE_NAMESPACE)
return jsonify(limit=limit, offset=offset, count=count, reviews=reviews)
def test_rate(self):
self.temporary_login(self.reviewer)
# Test for first time rating (no review exists)
payload = {
'entity_id': self.test_entity['id'],
'entity_type': 'release_group',
'rating': 4
}
response = self.client.post(url_for('rate.rate'), data=payload)
self.assertRedirects(
response, '/release-group/{}'.format(self.test_entity['id']))
reviews, review_count = db_review.list_reviews(
entity_id=self.test_entity['id'],
entity_type='release_group',
user_id=self.reviewer.id)
# Test that the rate request created a review
self.assertEqual(review_count, 1)
review = reviews[0]
self.assertEqual(review['text'], None)
self.assertEqual(review['rating'], 4)
response = self.client.get('/release-group/{}'.format(
self.test_entity['id']))
self.assert200(response)
self.assertIn('We have updated your rating for this entity!',
str(response.data))
# Test after rating is cleared for review with NO text
payload = {
'entity_id': self.test_entity['id'],
'entity_type': 'release_group',
'rating': None
}
response = self.client.post(url_for('rate.rate'), data=payload)
reviews, review_count = db_review.list_reviews(
entity_id=self.test_entity['id'],
entity_type='release_group',
user_id=self.reviewer.id)
# Test that the clear rating request results in deletion of review (because review-text was None)
self.assertEqual(review_count, 0)
# Test after rating is cleared for review with some text
self.review = db_review.create(
user_id=self.reviewer.id,
entity_id=self.test_entity['id'],
entity_type="release_group",
text="Test Review.",
rating=4,
is_draft=False,
license_id=self.license["id"],
)
payload = {
'entity_id': self.test_entity['id'],
'entity_type': 'release_group',
'rating': None
}
response = self.client.post(url_for('rate.rate'), data=payload)
reviews, review_count = db_review.list_reviews(
entity_id=self.test_entity['id'],
entity_type='release_group',
user_id=self.reviewer.id)
# Test that the clear rating request doesn't delete review (because review-text was not None)
self.assertEqual(review_count, 1)
review = reviews[0]
self.assertEqual(review['rating'], None)
def entity(id):
"""Artist page.
Displays release groups (split up into several sections depending on their
type), artist information (type, members/member of, external links).
"""
try:
artist = mb_artist.get_artist_by_id(str(id))
except mb_exceptions.NoDataFoundException:
raise NotFound(
gettext(
"Sorry, we couldn't find an artist with that MusicBrainz ID."))
# Note that some artists might not have a list of members because they are not a band
band_members = _get_band_members(artist)
artist_reviews_limit = ARTIST_REVIEWS_LIMIT
if request.args.get('reviews') == "all":
artist_reviews_limit = None
my_review = None
if current_user.is_authenticated:
my_reviews, my_count = db_review.list_reviews(
entity_id=artist['id'],
entity_type='artist',
user_id=current_user.id,
)
my_review = my_reviews[0] if my_count else None
reviews_offset = 0
reviews, reviews_count = db_review.list_reviews(
entity_id=artist['id'],
entity_type='artist',
sort='popularity',
limit=artist_reviews_limit,
offset=reviews_offset,
)
avg_rating = get_avg_rating(artist['id'], "artist")
rating_form = RatingEditForm(entity_id=id, entity_type='artist')
rating_form.rating.data = my_review['rating'] if my_review else None
release_type = request.args.get('release_type', default='album')
if release_type not in ['album', 'single', 'ep', 'broadcast',
'other']: # supported release types
raise BadRequest("Unsupported release type.")
page = int(request.args.get('page', default=1))
if page < 1:
return redirect(url_for('.reviews'))
release_groups_offset = (page - 1) * BROWSE_RELEASE_GROUPS_LIMIT
release_groups, release_group_count = mb_release_group.browse_release_groups(
artist_id=artist['id'],
release_types=[release_type],
limit=BROWSE_RELEASE_GROUPS_LIMIT,
offset=release_groups_offset,
)
for release_group in release_groups:
# TODO(roman): Count reviews instead of fetching them.
_, release_group_review_count = db_review.list_reviews( # pylint: disable=unused-variable
entity_id=release_group['id'],
entity_type='release_group',
sort='published_on',
limit=1,
)
release_group['review_count'] = release_group_review_count
return render_template(
'artist/entity.html',
id=artist['id'],
artist=artist,
release_type=release_type,
release_groups=release_groups,
page=page,
reviews=reviews,
reviews_limit=artist_reviews_limit,
reviews_count=reviews_count,
avg_rating=avg_rating,
rating_form=rating_form,
release_groups_limit=BROWSE_RELEASE_GROUPS_LIMIT,
release_group_count=release_group_count,
band_members=band_members,
)
def create():
entity_id, entity_type = None, None
for entity_type in ENTITY_TYPES:
entity_id = request.args.get(entity_type)
if entity_id:
entity_type = entity_type
break
if not (entity_id or entity_type):
logging.warning("Unsupported entity type")
raise BadRequest("Unsupported entity type")
if not entity_id:
flash.info(gettext("Please choose an entity to review."))
return redirect(url_for('search.selector', next=url_for('.create')))
if current_user.is_blocked:
flash.error(
gettext("You are not allowed to write new reviews because your "
"account has been blocked by a moderator."))
return redirect(url_for('user.reviews', user_id=current_user.id))
# Checking if the user already wrote a review for this entity
review = db_review.list_reviews(user_id=current_user.id,
entity_id=entity_id)[0]
if review:
flash.error(
gettext("You have already published a review for this entity!"))
return redirect(url_for('review.entity', id=review["id"]))
form = ReviewCreateForm(default_language=get_locale())
if form.validate_on_submit():
if current_user.is_review_limit_exceeded:
flash.error(
gettext("You have exceeded your limit of reviews per day."))
return redirect(url_for('user.reviews', user_id=current_user.id))
is_draft = form.state.data == 'draft'
if form.text.data == '':
form.text.data = None
review = db_review.create(user_id=current_user.id,
entity_id=entity_id,
entity_type=entity_type,
text=form.text.data,
rating=form.rating.data,
license_id=form.license_choice.data,
language=form.language.data,
is_draft=is_draft)
if is_draft:
flash.success(gettext("Review has been saved!"))
else:
flash.success(gettext("Review has been published!"))
return redirect(url_for('.entity', id=review['id']))
entity = get_entity_by_id(entity_id, entity_type)
if not entity:
flash.error(
gettext(
"You can only write a review for an entity that exists on MusicBrainz!"
))
return redirect(url_for('search.selector', next=url_for('.create')))
if entity_type == 'release_group':
spotify_mappings = mbspotify.mappings(entity_id)
soundcloud_url = soundcloud.get_url(entity_id)
if not form.errors:
flash.info(
gettext(
"Please provide some text or a rating for this review."))
return render_template('review/modify/write.html',
form=form,
entity_type=entity_type,
entity=entity,
spotify_mappings=spotify_mappings,
soundcloud_url=soundcloud_url)
if not form.errors:
flash.info(
gettext("Please provide some text or a rating for this review."))
return render_template('review/modify/write.html',
form=form,
entity_type=entity_type,
entity=entity)