byceps.blueprints.api.tourney.match.comments.views

Complexity

Total Complexity

19

Size/Duplication

Total Lines	209
Duplicated Lines	0 %

Importance

Changes

0

10 Functions

Rating	Name	Duplication	Size	Complexity
A	_parse_request()	0	10	2
A	update()	0	16	2
A	_comment_to_json()	0	20	2
A	view_for_match()	0	15	1
A	_get_match_or_404()	0	7	2
A	view_for_match_as_json()	0	16	1
A	create()	0	22	3
A	unhide()	0	17	2
A	hide()	0	16	2
A	_get_comment_or_404()	0	7	2

"""
byceps.blueprints.api.tourney.match.views
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

:Copyright: 2006-2019 Jochen Kupperschmidt
:License: Modified BSD, see LICENSE for details.
"""

from typing import Any, Dict

from flask import abort, jsonify, request, url_for
from marshmallow import ValidationError
from marshmallow.schema import SchemaMeta

from ......services.tourney import match_comment_service, match_service
from ......services.user import service as user_service
from ......util.framework.blueprint import create_blueprint
from ......util.framework.templating import templated
from ......util.views import respond_created, respond_no_content

from ....decorators import api_token_required

from ... import signals

from .schemas import (
    CreateMatchCommentRequest,
    ModerateMatchCommentRequest,
    UpdateMatchCommentRequest,
)


blueprint = create_blueprint('api_tourney_match_comments', __name__)


@blueprint.route('/matches/<uuid:match_id>/comments')
@api_token_required
@templated
def view_for_match(match_id):
    """Render the comments on a match."""
    match = _get_match_or_404(match_id)

    party_id = request.args.get('party_id')

    comments = match_comment_service.get_comments(
        match.id, party_id=party_id, include_hidden=False
    )

    return {
        'comments': comments,
    }


@blueprint.route('/matches/<uuid:match_id>/comments.json')
@api_token_required
def view_for_match_as_json(match_id):
    """Render the comments on a match as JSON."""
    match = _get_match_or_404(match_id)

    party_id = request.args.get('party_id')

    comments = match_comment_service.get_comments(
        match.id, party_id=party_id, include_hidden=True
    )

    comment_dtos = list(map(_comment_to_json, comments))

    return jsonify({
        'comments': comment_dtos,
    })


def _comment_to_json(comment):
    creator = comment.creator

    return {
        'comment_id': str(comment.id),
        'match_id': str(comment.match_id),
        'created_at': comment.created_at.isoformat(),
        'creator': {
            'user_id': str(creator.id),
            'screen_name': creator.screen_name,
            'suspended': creator.suspended,
            'deleted': creator.deleted,
            'avatar_url': creator.avatar_url,
            'is_orga': creator.is_orga,
        },
        'body': comment.body_rendered,
        'hidden': comment.hidden,
        'hidden_at': comment.hidden_at.isoformat() \
                     if (comment.hidden_at is not None) else None,
        'hidden_by_id': comment.hidden_by_id,
    }


blueprint.add_url_rule(
    '/match_comments/<uuid:comment_id>',
    endpoint='view',
    build_only=True,
)


@blueprint.route('/match_comments', methods=['POST'])
@api_token_required
@respond_created
def create():
    """Create a comment on a match."""
    req = _parse_request(CreateMatchCommentRequest)

    match = match_service.find_match(req['match_id'])
    if not match:
        abort(400, 'Unknown match ID')

    creator = user_service.find_active_user(req['creator_id'])
    if not creator:
        abort(400, 'Creator ID does not reference an active user.')

    body = req['body'].strip()

    comment = match_comment_service.create_comment(match.id, creator.id, body)

    signals.match_comment_created.send(None, comment_id=comment.id)

    return url_for('.view', comment_id=comment.id)


@blueprint.route('/match_comments/<uuid:comment_id>', methods=['PATCH'])
@api_token_required
@respond_no_content
def update(comment_id):
    """Update a comment on a match."""
    comment = _get_comment_or_404(comment_id)

    req = _parse_request(UpdateMatchCommentRequest)

    editor = user_service.find_active_user(req['editor_id'])
    if not editor:
        abort(400, 'Editor ID does not reference an active user.')

    body = req['body'].strip()

    match_comment_service.update_comment(comment.id, editor.id, body)


@blueprint.route(

This code seems to be duplicated in your project.

    '/match_comments/<uuid:comment_id>/flags/hidden', methods=['POST']
)
@api_token_required
@respond_no_content
def hide(comment_id):
    """Hide the match comment."""
    comment = _get_comment_or_404(comment_id)

    req = _parse_request(ModerateMatchCommentRequest)

    initiator = user_service.find_active_user(req['initiator_id'])
    if not initiator:
        abort(400, 'Initiator ID does not reference an active user.')

    match_comment_service.hide_comment(comment.id, initiator.id)


@blueprint.route(

This code seems to be duplicated in your project.

    '/match_comments/<uuid:comment_id>/flags/hidden',
    methods=['DELETE'],
)
@api_token_required
@respond_no_content
def unhide(comment_id):
    """Un-hide the match comment."""
    comment = _get_comment_or_404(comment_id)

    req = _parse_request(ModerateMatchCommentRequest)

    initiator = user_service.find_active_user(req['initiator_id'])
    if not initiator:
        abort(400, 'Initiator ID does not reference an active user.')

    match_comment_service.unhide_comment(comment.id, initiator.id)


def _get_match_or_404(match_id):
    match = match_service.find_match(match_id)

    if match is None:
        abort(404)

    return match


def _get_comment_or_404(comment_id):
    comment = match_comment_service.find_comment(comment_id)

    if comment is None:
        abort(404)

    return comment


def _parse_request(schema_class: SchemaMeta) -> Dict[str, Any]:
    schema = schema_class()
    request_data = request.get_json()

    try:
        req = schema.load(request_data)
    except ValidationError as e:
        abort(400, str(e.normalized_messages()))

    return req