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}))
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}))
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.')
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.')
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]))
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]))
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]))
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})
)
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.')
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)
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
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
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
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
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()
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
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
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
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
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()
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)