Exemplo n.º 1
0
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)
Exemplo n.º 2
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)
Exemplo n.º 3
0
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)
Exemplo n.º 4
0
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)
Exemplo n.º 5
0
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)
Exemplo n.º 6
0
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)
Exemplo n.º 7
0
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)
Exemplo n.º 8
0
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"])
Exemplo n.º 9
0
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)
Exemplo n.º 10
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)
Exemplo n.º 11
0
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)
Exemplo n.º 12
0
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)
Exemplo n.º 13
0
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)
Exemplo n.º 14
0
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)
Exemplo n.º 15
0
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)
Exemplo n.º 16
0
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)
Exemplo n.º 17
0
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)
Exemplo n.º 18
0
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)
Exemplo n.º 19
0
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)
Exemplo n.º 20
0
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)
Exemplo n.º 21
0
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)
Exemplo n.º 22
0
    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']
Exemplo n.º 23
0
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)