Beispiel #1
0
def upload_async(request, media_type='image'):
    """Upload images or videos from request.FILES."""
    # TODO(paul): validate the Submit File on upload modal async
    #             even better, use JS validation for title length.
    try:
        if media_type == 'image':
            file_info = upload_image(request)
        else:
            msg = _(u'Unrecognized media type.')
            return HttpResponseBadRequest(
                json.dumps({'status': 'error', 'message': msg}))
    except FileTooLargeError as e:
        return HttpResponseBadRequest(
            json.dumps({'status': 'error', 'message': e.args[0]}))

    if isinstance(file_info, dict) and 'thumbnail_url' in file_info:
        schedule_rebuild_kb()
        return HttpResponse(
            json.dumps({'status': 'success', 'file': file_info}))

    message = _(u'Could not upload your image.')
    return HttpResponseBadRequest(
        json.dumps({'status': 'error',
                    'message': unicode(message),
                    'errors': file_info}))
Beispiel #2
0
def upload_async(request, media_type='image'):
    """Upload images or videos from request.FILES."""
    # TODO(paul): validate the Submit File on upload modal async
    #             even better, use JS validation for title length.
    try:
        if media_type == 'image':
            file_info = upload_image(request)
        else:
            msg = _(u'Unrecognized media type.')
            return HttpResponseBadRequest(
                json.dumps({'status': 'error', 'message': msg}))
    except FileTooLargeError as e:
        return HttpResponseBadRequest(
            json.dumps({'status': 'error', 'message': e.args[0]}))

    if isinstance(file_info, dict) and 'thumbnail_url' in file_info:
        schedule_rebuild_kb()
        return HttpResponse(
            json.dumps({'status': 'success', 'file': file_info}))

    message = _(u'Could not upload your image.')
    return HttpResponseBadRequest(
        json.dumps({'status': 'error',
                    'message': unicode(message),
                    'errors': file_info}))
Beispiel #3
0
def upload(request, media_type='image'):
    """Finalizes an uploaded draft."""
    drafts = _get_drafts(request.user)
    if media_type == 'image' and drafts['image']:
        # We're publishing an image draft!
        image_form = _init_media_form(ImageForm, request, drafts['image'][0])
        if image_form.is_valid():
            img = image_form.save(is_draft=None)
            generate_thumbnail.delay(img, 'file', 'thumbnail')
            compress_image.delay(img, 'file')
            # Rebuild KB
            schedule_rebuild_kb()
            return HttpResponseRedirect(img.get_absolute_url())
        else:
            return gallery(request, media_type='image')

    return HttpResponseBadRequest(u'Unrecognized POST request.')
Beispiel #4
0
def upload(request, media_type='image'):
    """Finalizes an uploaded draft."""
    drafts = _get_drafts(request.user)
    if media_type == 'image' and drafts['image']:
        # We're publishing an image draft!
        image_form = _init_media_form(ImageForm, request, drafts['image'][0])
        if image_form.is_valid():
            img = image_form.save(is_draft=None)
            generate_thumbnail.delay(img, 'file', 'thumbnail')
            compress_image.delay(img, 'file')
            # Rebuild KB
            schedule_rebuild_kb()
            return HttpResponseRedirect(img.get_absolute_url())
        else:
            return gallery(request, media_type='image')

    return HttpResponseBadRequest(u'Unrecognized POST request.')
Beispiel #5
0
def delete_media(request, media_id, media_type='image'):
    """Delete media and redirect to gallery view."""
    media, media_format = _get_media_info(media_id, media_type)

    check_media_permissions(media, request.user, 'delete')

    if request.method == 'GET':
        # Render the confirmation page
        return render(request, 'gallery/confirm_media_delete.html', {
            'media': media,
            'media_type': media_type,
            'media_format': media_format})

    # Handle confirm delete form POST
    log.warning('User %s is deleting %s with id=%s' %
                (request.user, media_type, media.id))
    media.delete()
    # Rebuild KB
    schedule_rebuild_kb()
    return HttpResponseRedirect(reverse('gallery.gallery', args=[media_type]))
Beispiel #6
0
def delete_media(request, media_id, media_type="image"):
    """Delete media and redirect to gallery view."""
    media, media_format = _get_media_info(media_id, media_type)

    check_media_permissions(media, request.user, "delete")

    if request.method == "GET":
        # Render the confirmation page
        return render(
            request,
            "gallery/confirm_media_delete.html",
            {"media": media, "media_type": media_type, "media_format": media_format},
        )

    # Handle confirm delete form POST
    log.warning("User %s is deleting %s with id=%s" % (request.user, media_type, media.id))
    media.delete()
    # Rebuild KB
    schedule_rebuild_kb()
    return HttpResponseRedirect(reverse("gallery.gallery", args=[media_type]))
Beispiel #7
0
def delete_media(request, media_id, media_type='image'):
    """Delete media and redirect to gallery view."""
    media, media_format = _get_media_info(media_id, media_type)

    check_media_permissions(media, request.user, 'delete')

    if request.method == 'GET':
        # Render the confirmation page
        return render(request, 'gallery/confirm_media_delete.html', {
            'media': media,
            'media_type': media_type,
            'media_format': media_format})

    # Handle confirm delete form POST
    log.warning('User %s is deleting %s with id=%s' %
                (request.user, media_type, media.id))
    media.delete()
    # Rebuild KB
    schedule_rebuild_kb()
    return HttpResponseRedirect(reverse('gallery.gallery', args=[media_type]))
Beispiel #8
0
def upload_async(request, media_type="image"):
    """Upload images or videos from request.FILES."""
    # TODO(paul): validate the Submit File on upload modal async
    #             even better, use JS validation for title length.
    try:
        if media_type == "image":
            file_info = upload_image(request)
        else:
            msg = _("Unrecognized media type.")
            return HttpResponseBadRequest(json.dumps({"status": "error", "message": msg}))
    except FileTooLargeError as e:
        return HttpResponseBadRequest(json.dumps({"status": "error", "message": e.args[0]}))

    if isinstance(file_info, dict) and "thumbnail_url" in file_info:
        schedule_rebuild_kb()
        return HttpResponse(json.dumps({"status": "success", "file": file_info}))

    message = _("Could not upload your image.")
    return HttpResponseBadRequest(
        json.dumps({"status": "error", "message": str(message), "errors": file_info})
    )
Beispiel #9
0
def upload(request, media_type='image'):
    """Finalizes an uploaded draft."""
    drafts = _get_drafts(request.user)
    if media_type == 'image' and drafts['image']:
        # We're publishing an image draft!
        image_form = _init_media_form(ImageForm, request, drafts['image'][0])
        if image_form.is_valid():
            img = image_form.save(is_draft=None)
            generate_thumbnail.delay(img, 'file', 'thumbnail')
            compress_image.delay(img, 'file')
            # TODO: We can drop this when we start using Redis.
            invalidate = Image.objects.exclude(pk=img.pk)
            if invalidate.exists():
                Image.objects.invalidate(invalidate[0])
            # Rebuild KB
            schedule_rebuild_kb()
            return HttpResponseRedirect(img.get_absolute_url())
        else:
            return gallery(request, media_type='image')
    elif media_type == 'video' and drafts['video']:
        # We're publishing a video draft!
        video_form = _init_media_form(VideoForm, request, drafts['video'][0])
        if video_form.is_valid():
            vid = video_form.save(is_draft=None)
            if vid.thumbnail:
                generate_thumbnail.delay(vid, 'poster', 'poster',
                                         max_size=settings.WIKI_VIDEO_WIDTH)
                generate_thumbnail.delay(vid, 'thumbnail', 'thumbnail')
            # TODO: We can drop this when we start using Redis.
            invalidate = Video.objects.exclude(pk=vid.pk)
            if invalidate.exists():
                Video.objects.invalidate(invalidate[0])
            # Rebuild KB
            schedule_rebuild_kb()
            return HttpResponseRedirect(vid.get_absolute_url())
        else:
            return gallery(request, media_type='video')

    return HttpResponseBadRequest(u'Unrecognized POST request.')
Beispiel #10
0
def review_revision(request, document_slug, revision_id):
    """Review a revision of a wiki document."""
    rev = get_object_or_404(Revision, pk=revision_id,
                            document__slug=document_slug)
    doc = rev.document

    if not doc.allows(request.user, 'review_revision'):
        raise PermissionDenied

    form = ReviewForm(
        initial={'needs_change': doc.needs_change,
                 'needs_change_comment': doc.needs_change_comment})

    # Don't ask significance if this doc is a translation or if it has no
    # former approved versions:
    should_ask_significance = not doc.parent and doc.current_revision

    based_on_revs = doc.revisions.all()
    last_approved_date = getattr(doc.current_revision, 'created',
                                   datetime.fromordinal(1))
    based_on_revs = based_on_revs.filter(created__gt=last_approved_date)
    revision_contributors = list(set(
        based_on_revs.values_list('creator__username', flat=True)))

    # Don't include the reviewer in the recent contributors list.
    if request.user.username in revision_contributors:
        revision_contributors.remove(request.user.username)

    if request.method == 'POST':
        form = ReviewForm(request.POST)
        if form.is_valid() and not rev.reviewed:
            # Don't allow revisions to be reviewed twice
            rev.is_approved = 'approve' in request.POST
            rev.reviewer = request.user
            rev.reviewed = datetime.now()

            if should_ask_significance and form.cleaned_data['significance']:
                rev.significance = form.cleaned_data['significance']
            elif not should_ask_significance and not doc.parent:
                # This is a new document without approved revisions.
                # Significance is MAJOR.
                rev.significance = MAJOR_SIGNIFICANCE

            # If document is localizable and revision was approved and
            # user has permission, set the is_ready_for_localization value.
            if (doc.allows(request.user, 'mark_ready_for_l10n') and
                rev.is_approved and rev.can_be_readied_for_localization()):
                rev.is_ready_for_localization = form.cleaned_data[
                    'is_ready_for_localization']

                # If the revision is ready for l10n, store the date
                # and the user.
                if rev.is_ready_for_localization:
                    rev.readied_for_localization = rev.reviewed
                    rev.readied_for_localization_by = rev.reviewer

            rev.save()

            # Update the needs change bit (if approved, default language and
            # user has permission).
            if (doc.locale == settings.WIKI_DEFAULT_LANGUAGE and
                doc.allows(request.user, 'edit_needs_change') and
                rev.is_approved):

                doc.needs_change = form.cleaned_data['needs_change']
                doc.needs_change_comment = \
                    form.cleaned_data['needs_change_comment']
                doc.save()

            # Send notifications of approvedness and readiness:
            if rev.is_ready_for_localization or rev.is_approved:
                events = [ApproveRevisionInLocaleEvent(rev)]
                if rev.is_ready_for_localization:
                    events.append(ReadyRevisionEvent(rev))
                ApprovedOrReadyUnion(*events).fire(exclude=[rev.creator,
                                                            request.user])

            # Send an email (not really a "notification" in the sense that
            # there's a Watch table entry) to revision creator.
            msg = form.cleaned_data['comment']
            send_reviewed_notification.delay(rev, doc, msg)
            send_contributor_notification(based_on_revs, rev, doc, msg)

            # Schedule KB rebuild?
            statsd.incr('wiki.review')
            schedule_rebuild_kb()

            return HttpResponseRedirect(reverse('wiki.document_revisions',
                                                args=[document_slug]))

    if doc.parent:  # A translation
        # For diffing the based_on revision against, to help the user see if he
        # translated all the recent changes:
        parent_revision = (rev.based_on or
                           doc.parent.localizable_or_latest_revision())
        template = 'wiki/review_translation.html'
    else:
        parent_revision = None
        template = 'wiki/review_revision.html'

    data = {'revision': rev, 'document': doc, 'form': form,
            'parent_revision': parent_revision,
            'revision_contributors': list(revision_contributors),
            'should_ask_significance': should_ask_significance}
    return render(request, template, data)
Beispiel #11
0
 def test_dont_queue(self, switch_is_active, get, delay):
     switch_is_active.return_value = False
     schedule_rebuild_kb()
     assert not get.called
     assert not delay.called
Beispiel #12
0
 def test_already_queued(self, switch_is_active, delay):
     switch_is_active.return_value = True
     cache.set(settings.WIKI_REBUILD_TOKEN, True)
     schedule_rebuild_kb()
     assert cache.get(settings.WIKI_REBUILD_TOKEN)
     assert not delay.called
Beispiel #13
0
 def test_task_queue(self, switch_is_active, delay):
     switch_is_active.return_value = True
     settings.CELERY_ALWAYS_EAGER = False
     schedule_rebuild_kb()
     assert cache.get(settings.WIKI_REBUILD_TOKEN)
     assert delay.called
Beispiel #14
0
 def test_eager_queue(self, switch_is_active, delay):
     switch_is_active.return_value = True
     schedule_rebuild_kb()
     assert not cache.get(settings.WIKI_REBUILD_TOKEN)
     assert not delay.called
Beispiel #15
0
def _maybe_schedule_rebuild(form):
    """Try to schedule a KB rebuild if a title or slug has changed."""
    if 'title' in form.changed_data or 'slug' in form.changed_data:
        schedule_rebuild_kb()
Beispiel #16
0
 def test_dont_queue(self, switch_is_active, get, delay):
     switch_is_active.return_value = False
     schedule_rebuild_kb()
     assert not get.called
     assert not delay.called
Beispiel #17
0
 def test_already_queued(self, switch_is_active, delay):
     switch_is_active.return_value = True
     cache.set(settings.WIKI_REBUILD_TOKEN, True)
     schedule_rebuild_kb()
     assert cache.get(settings.WIKI_REBUILD_TOKEN)
     assert not delay.called
Beispiel #18
0
 def test_task_queue(self, switch_is_active, delay):
     switch_is_active.return_value = True
     settings.CELERY_ALWAYS_EAGER = False
     schedule_rebuild_kb()
     assert cache.get(settings.WIKI_REBUILD_TOKEN)
     assert delay.called
Beispiel #19
0
 def test_eager_queue(self, switch_is_active, delay):
     switch_is_active.return_value = True
     schedule_rebuild_kb()
     assert not cache.get(settings.WIKI_REBUILD_TOKEN)
     assert not delay.called
Beispiel #20
0
def _maybe_schedule_rebuild(form):
    """Try to schedule a KB rebuild if a title or slug has changed."""
    if 'title' in form.changed_data or 'slug' in form.changed_data:
        schedule_rebuild_kb()
Beispiel #21
0
def review_revision(request, document_slug, revision_id):
    """Review a revision of a wiki document."""
    rev = get_object_or_404(Revision,
                            pk=revision_id,
                            document__slug=document_slug)
    doc = rev.document

    if not doc.allows(request.user, 'review_revision'):
        raise PermissionDenied

    form = ReviewForm(
        initial={
            'needs_change': doc.needs_change,
            'needs_change_comment': doc.needs_change_comment
        })

    # Don't ask significance if this doc is a translation or if it has no
    # former approved versions:
    should_ask_significance = not doc.parent and doc.current_revision

    based_on_revs = doc.revisions.all()
    last_approved_date = getattr(doc.current_revision, 'created',
                                 datetime.fromordinal(1))
    based_on_revs = based_on_revs.filter(created__gt=last_approved_date)
    revision_contributors = list(
        set(based_on_revs.values_list('creator__username', flat=True)))

    # Don't include the reviewer in the recent contributors list.
    if request.user.username in revision_contributors:
        revision_contributors.remove(request.user.username)

    if request.method == 'POST':
        form = ReviewForm(request.POST)
        if form.is_valid() and not rev.reviewed:
            # Don't allow revisions to be reviewed twice
            rev.is_approved = 'approve' in request.POST
            rev.reviewer = request.user
            rev.reviewed = datetime.now()
            if should_ask_significance and form.cleaned_data['significance']:
                rev.significance = form.cleaned_data['significance']

            # If document is localizable and revision was approved and
            # user has permission, set the is_ready_for_localization value.
            if (doc.allows(request.user, 'mark_ready_for_l10n')
                    and rev.is_approved
                    and rev.can_be_readied_for_localization()):
                rev.is_ready_for_localization = form.cleaned_data[
                    'is_ready_for_localization']

                # If the revision is ready for l10n, store the date
                # and the user.
                if rev.is_ready_for_localization:
                    rev.readied_for_localization = rev.reviewed
                    rev.readied_for_localization_by = rev.reviewer

            rev.save()

            # Update the needs change bit (if approved, default language and
            # user has permission).
            if (doc.locale == settings.WIKI_DEFAULT_LANGUAGE
                    and doc.allows(request.user, 'edit_needs_change')
                    and rev.is_approved):

                doc.needs_change = form.cleaned_data['needs_change']
                doc.needs_change_comment = \
                    form.cleaned_data['needs_change_comment']
                doc.save()

            # Send notifications of approvedness and readiness:
            if rev.is_ready_for_localization or rev.is_approved:
                events = [ApproveRevisionInLocaleEvent(rev)]
                if rev.is_ready_for_localization:
                    events.append(ReadyRevisionEvent(rev))
                ApprovedOrReadyUnion(*events).fire(
                    exclude=[rev.creator, request.user])

            # Send an email (not really a "notification" in the sense that
            # there's a Watch table entry) to revision creator.
            msg = form.cleaned_data['comment']
            send_reviewed_notification.delay(rev, doc, msg)
            send_contributor_notification(based_on_revs, rev, doc, msg)

            # Schedule KB rebuild?
            statsd.incr('wiki.review')
            schedule_rebuild_kb()

            return HttpResponseRedirect(
                reverse('wiki.document_revisions', args=[document_slug]))

    if doc.parent:  # A translation
        # For diffing the based_on revision against, to help the user see if he
        # translated all the recent changes:
        parent_revision = (rev.based_on
                           or doc.parent.localizable_or_latest_revision())
        template = 'wiki/review_translation.html'
    else:
        parent_revision = None
        template = 'wiki/review_revision.html'

    data = {
        'revision': rev,
        'document': doc,
        'form': form,
        'parent_revision': parent_revision,
        'revision_contributors': list(revision_contributors),
        'should_ask_significance': should_ask_significance
    }
    data.update(showfor_data())
    return render(request, template, data)