def edit(id): review = Review.query.get_or_404(str(id)) if review.is_draft and current_user != review.user: raise NotFound(gettext("Can't find a review with the specified ID.")) if review.user != current_user: raise Unauthorized(gettext("Only author can edit this review.")) if review.is_hidden and not current_user.is_admin(): raise NotFound(gettext("Review has been hidden.")) form = ReviewEditForm(default_license_id=review.license_id, default_language=review.language) if not review.is_draft: # Can't change license if review is published. del form.license_choice if form.validate_on_submit(): if review.is_draft: license_choice = form.license_choice.data else: license_choice = None review.update(text=form.text.data, is_draft=(form.state.data == 'draft'), license_id=license_choice, language=form.language.data) flash(gettext("Review has been updated."), 'success') return redirect(url_for('.entity', id=review.id)) else: form.text.data = review.text if review.entity_type == 'release_group': spotify_mappings = mbspotify.mappings(review.entity_id) return render_template('review/modify/edit.html', form=form, review=review, entity_type=review.entity_type, entity=entity, spotify_mappings = spotify_mappings) return render_template('review/modify/edit.html', form=form, review=review, entity_type=review.entity_type)
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 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 entity(id, rev=None): review = Review.query.get_or_404(str(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(gettext("Review has been hidden."), 'warning') spotify_mappings = None if review.entity_type == 'release_group': spotify_mappings = mbspotify.mappings(review.entity_id) revisions = Revision.query.filter_by(review=review).order_by(desc(Revision.timestamp)) count = revisions.count() if not rev: rev = count if rev < count: flash(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 = revisions.offset(count-rev).first() if not review.is_draft and current_user.is_authenticated(): # if user is logged in, get his vote for this review vote = Vote.query.filter_by(user=current_user, revision=revision).first() else: # otherwise set vote to None, its value will not be used vote = None review.text_html = markdown(revision.text, safe_mode="escape") return render_template('review/entity/%s.html' % review.entity_type, review=review, spotify_mappings=spotify_mappings, vote=vote)
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 release_group = musicbrainz.get_release_group_by_id(release_group_id) if not release_group: flash(gettext("Can't find release group with that ID!"), 'error') 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 not (spotify_uri in spotify_mappings): flash(gettext("This album is not mapped to Spotify yet!"), 'error') 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(gettext("Incorrect Spotify mapping has been reported. Thank you!"), 'success') return redirect(url_for('.spotify_list', release_group_id=release_group_id)) else: album = spotify_api.get_album(spotify_id) if not album or album.get('error'): flash(gettext("You need to specify existing album from Spotify!"), 'error') 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 edit(id): review = Review.query.get_or_404(str(id)) if review.is_draft and current_user != review.user: raise NotFound(gettext("Can't find a review with the specified ID.")) if review.user != current_user: raise Unauthorized(gettext("Only author can edit this review.")) if review.is_hidden and not current_user.is_admin(): raise NotFound(gettext("Review has been hidden.")) form = ReviewEditForm(default_license_id=review.license_id, default_language=review.language) if not review.is_draft: # Can't change license if review is published. del form.license_choice if form.validate_on_submit(): if review.is_draft: license_choice = form.license_choice.data else: license_choice = None review.update(text=form.text.data, is_draft=(form.state.data == 'draft'), license_id=license_choice, language=form.language.data) flash(gettext("Review has been updated."), 'success') return redirect(url_for('.entity', id=review.id)) else: form.text.data = review.text if review.entity_type == 'release_group': spotify_mappings = mbspotify.mappings(review.entity_id) return render_template('review/edit.html', form=form, review=review, entity_type=review.entity_type, entity=entity, spotify_mappings = spotify_mappings) return render_template('review/edit.html', form=form, review=review, entity_type=review.entity_type)
def edit(id): review = get_review_or_404(id) if review["is_draft"] and current_user != review["user"]: raise NotFound(gettext("Can't find a review with the specified ID.")) if review["user"] != current_user: raise Unauthorized(gettext("Only author can edit this review.")) if review["is_hidden"] and not current_user.is_admin(): raise NotFound(gettext("Review has been hidden.")) form = ReviewEditForm(default_license_id=review["license_id"], default_language=review["language"]) if not review["is_draft"]: # Can't change license if review is published. del form.license_choice if form.validate_on_submit(): if review["is_draft"]: license_choice = form.license_choice.data else: license_choice = None if form.text.data == '': form.text.data = None try: db_review.update( review_id=review["id"], drafted=review["is_draft"], text=form.text.data, rating=form.rating.data, is_draft=(form.state.data == 'draft'), license_id=license_choice, language=form.language.data, ) except db_exceptions.BadDataException: raise BadRequest( lazy_gettext("Changing license of a published review\ or converting a published review back to drafts is not allowed." )) flash.success(gettext("Review has been updated.")) return redirect(url_for('.entity', id=review["id"])) else: form.text.data = review["text"] form.rating.data = review["rating"] if review["entity_type"] == 'release_group': spotify_mappings = mbspotify.mappings(str(review["entity_id"])) soundcloud_url = soundcloud.get_url(str(review["entity_id"])) return render_template('review/modify/edit.html', form=form, review=review, entity_type=review["entity_type"], entity=entity, spotify_mappings=spotify_mappings, soundcloud_url=soundcloud_url) return render_template('review/modify/edit.html', form=form, review=review, entity_type=review["entity_type"])
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 entity(id): id = str(id) release_group = musicbrainz.get_release_group_by_id(id) if not release_group: 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 len(release_group['release-list']) > 0: release = musicbrainz.get_release_by_id( release_group['release-list'][0]['id']) else: release = None soundcloud_url = soundcloud.get_url(id) if soundcloud_url: spotify_mappings = None else: spotify_mappings = mbspotify.mappings(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 = Review.list(entity_id=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 = Review.list(entity_id=id, entity_type='release_group', sort='rating', limit=limit, offset=offset) return render_template('release_group/entity.html', id=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)
def create(): for entity_type in ENTITY_TYPES: entity_id = request.args.get(entity_type) if entity_id: break if not entity_id: flash(gettext("Please choose an entity to review.")) return redirect(url_for('search.selector', next=url_for('.create'))) if current_user.is_blocked: flash(gettext("You are not allowed to write new reviews because your " "account has been blocked by a moderator."), 'error') return redirect(url_for('user.reviews', user_id=current_user.id)) # Checking if the user already wrote a review for this entity review = Review.query.filter_by(user=current_user, entity_id=entity_id).first() if review: flash(gettext("You have already published a review for this entity!"), 'error') 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(gettext("You have exceeded your limit of reviews per day."), 'error') return redirect(url_for('user.reviews', user_id=current_user.id)) is_draft = form.state.data == 'draft' review = Review.create(user=current_user, entity_id=entity_id, entity_type=entity_type, text=form.text.data, license_id=form.license_choice.data, language=form.language.data, is_draft=is_draft) if is_draft: flash(gettext("Review has been saved!"), 'success') else: flash(gettext("Review has been published!"), 'success') return redirect(url_for('.entity', id=review.id)) entity = musicbrainz.get_entity_by_id(entity_id, entity_type) if not entity: flash(gettext("You can only write a review for an entity that exists on MusicBrainz!"), 'error') return redirect(url_for('search.selector', next=url_for('.create'))) if entity_type == 'release_group': spotify_mappings = mbspotify.mappings(entity_id) return render_template('review/modify/write.html', form=form, entity_type=entity_type, entity=entity, spotify_mappings = spotify_mappings) return render_template('review/modify/write.html', form=form, entity_type=entity_type, entity=entity)
def create(): for entity_type in ENTITY_TYPES: entity_id = request.args.get(entity_type) if entity_id: break if not entity_id: flash(gettext("Please choose an entity to review.")) return redirect(url_for('search.selector', next=url_for('.create'))) if current_user.is_blocked: flash(gettext("You are not allowed to write new reviews because your " "account has been blocked by a moderator."), 'error') return redirect(url_for('user.reviews', user_id=current_user.id)) # Checking if the user already wrote a review for this entity review = Review.query.filter_by(user=current_user, entity_id=entity_id).first() if review: flash(gettext("You have already published a review for this entity!"), 'error') 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(gettext("You have exceeded your limit of reviews per day."), 'error') return redirect(url_for('user.reviews', user_id=current_user.id)) is_draft = form.state.data == 'draft' review = Review.create(user=current_user, entity_id=entity_id, entity_type=entity_type, text=form.text.data, license_id=form.license_choice.data, language=form.language.data, is_draft=is_draft) if is_draft: flash(gettext("Review has been saved!"), 'success') else: flash(gettext("Review has been published!"), 'success') return redirect(url_for('.entity', id=review.id)) entity = musicbrainz.get_entity_by_id(entity_id, entity_type) if not entity: flash(gettext("You can only write a review for an entity that exists on MusicBrainz!"), 'error') return redirect(url_for('search.selector', next=url_for('.create'))) if entity_type == 'release_group': spotify_mappings = mbspotify.mappings(entity_id) return render_template('review/write.html', form=form, entity_type=entity_type, entity=entity, spotify_mappings = spotify_mappings) return render_template('review/write.html', form=form, entity_type=entity_type, entity=entity)
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 len(spotify_ids) > 0: spotify_albums = spotify_api.get_multiple_albums(spotify_ids) else: spotify_albums = [] release_group = musicbrainz.get_release_group_by_id(release_group_id) if not release_group: 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_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_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 release_group = musicbrainz.get_release_group_by_id(release_group_id) if not release_group: flash(gettext("Can't find release group with that ID!"), 'error') 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 not (spotify_uri in spotify_mappings): flash(gettext("This album is not mapped to Spotify yet!"), 'error') 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( gettext("Incorrect Spotify mapping has been reported. Thank you!"), 'success') return redirect( url_for('.spotify_list', release_group_id=release_group_id)) else: album = spotify_api.get_album(spotify_id) if not album or album.get('error'): flash(gettext("You need to specify existing album from Spotify!"), 'error') 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_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_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 entity(id): id = str(id) release_group = musicbrainz.get_release_group_by_id(id) if not release_group: raise NotFound(gettext("Sorry, we couldn't find a release group with that MusicBrainz ID.")) if len(release_group['release-list']) > 0: release = musicbrainz.get_release_by_id(release_group['release-list'][0]['id']) else: release = None spotify_mappings = mbspotify.mappings(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 = Review.list(entity_id=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 = Review.list(entity_id=id, entity_type='release_group', sort='rating', limit=limit, offset=offset) return render_template('release_group/entity.html', id=id, release_group=release_group, reviews=reviews, release=release, my_review=my_review, spotify_mappings=spotify_mappings, limit=limit, offset=offset, count=count)
try: entity = get_entity_by_id(entity_id, entity_type) except NoDataFoundException: raise NotFound( gettext("Sorry, we couldn't find a %s with that MusicBrainz 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) entity_title = None if 'title' in entity: entity_title = entity['title']
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)