def confirm_auto_approved(self):
"""Confirm an auto-approval decision.
We don't need to really store that information, what we care about
is logging something for future reviewers to be aware of, and, if the
version is listed, incrementing AddonApprovalsCounter, which also
resets the last human review date to now, and log it so that it's
displayed later in the review page."""
status = self.addon.status
latest_version = self.version
# The confirm auto-approval action should not show the comment box,
# so override the text in case the reviewer switched between actions
# and accidently submitted some comments from another action.
self.data['comments'] = ''
if self.content_review_only:
# If we're only doing a content review, then don't increment
# the counter, just record the date of the content approval
# and log it.
AddonApprovalsCounter.approve_content_for_addon(addon=self.addon)
self.log_action(amo.LOG.APPROVE_CONTENT)
else:
if self.version.channel == amo.RELEASE_CHANNEL_LISTED:
self.version.autoapprovalsummary.update(confirmed=True)
AddonApprovalsCounter.increment_for_addon(addon=self.addon)
self.log_action(amo.LOG.CONFIRM_AUTO_APPROVED)
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(
self.request.user, self.addon, status, version=latest_version,
post_review=True, content_review=self.content_review_only)
def award_all_points_for_action(self, action, content_review=False):
for activity_log in ActivityLog.objects.filter(action=action.id):
user = activity_log.user
try:
addon = activity_log.arguments[0]
version = activity_log.arguments[1]
except IndexError:
log.error('ActivityLog %d is missing one or more arguments',
activity_log.pk)
continue
# If there is already a score recorded in the database for this
# event, with our special note, it means we already processed it
# somehow (maybe we ran the script twice...), so ignore it.
# Otherwise award the points!
event = ReviewerScore.get_event(
addon, amo.STATUS_PUBLIC, version=version,
post_review=True, content_review=content_review)
if not ReviewerScore.objects.filter(
user=user, addon=addon, note_key=event,
note=MANUAL_NOTE).exists():
ReviewerScore.award_points(
user, addon, amo.STATUS_PUBLIC,
version=version, post_review=True,
content_review=content_review, extra_note=MANUAL_NOTE)
else:
log.error('Already awarded points for "%s" action on %s %s',
action.short, addon, version)
continue
def process_public(self, auto_validation=False):
"""Set an addon to public."""
# Sign addon.
for file_ in self.files:
sign_file(file_, settings.SIGNING_SERVER)
# Hold onto the status before we change it.
status = self.addon.status
# Save files first, because set_addon checks to make sure there
# is at least one public file or it won't make the addon public.
self.set_files(amo.STATUS_PUBLIC, self.files, copy_to_mirror=True)
self.set_addon(status=amo.STATUS_PUBLIC)
self.log_action(amo.LOG.APPROVE_VERSION)
template = u'%s_to_public' % self.review_type
subject = u'Mozilla Add-ons: %s %s Approved'
if not self.addon.is_listed:
template = u'unlisted_to_reviewed'
if auto_validation:
template = u'unlisted_to_reviewed_auto'
subject = u'Mozilla Add-ons: %s %s signed and ready to download'
self.notify_email(template, subject)
log.info(u'Making %s public' % (self.addon))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request and not auto_validation:
ReviewerScore.award_points(self.request.user, self.addon, status)
def process_sandbox(self):
"""Set an addon back to sandbox."""
# Hold onto the status before we change it.
status = self.addon.status
if (not self.is_upgrade
or not self.addon.versions.exclude(id=self.version.id).filter(
files__status__in=amo.REVIEWED_STATUSES)):
self.set_addon(status=amo.STATUS_NULL)
else:
self.set_addon(status=amo.STATUS_LITE)
self.set_files(amo.STATUS_DISABLED,
self.files,
hide_disabled_file=True)
self.log_action(amo.LOG.REJECT_VERSION)
template = u'%s_to_sandbox' % self.review_type
subject = u'Mozilla Add-ons: %s %s didn\'t pass review'
if not self.addon.is_listed:
template = u'unlisted_to_sandbox'
subject = u'Mozilla Add-ons: %s %s didn\'t pass review'
self.notify_email(template, subject)
log.info(u'Making %s disabled' % (self.addon))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(self.request.user, self.addon, status)
def process_public(self, auto_validation=False):
"""Set an addons files to public."""
if self.review_type == 'preliminary':
raise AssertionError('Preliminary addons cannot be made public.')
# Sign addon.
for file_ in self.files:
sign_file(file_, settings.SIGNING_SERVER)
# Hold onto the status before we change it.
status = self.addon.status
self.set_files(amo.STATUS_PUBLIC, self.files, copy_to_mirror=True)
self.log_action(amo.LOG.APPROVE_VERSION)
template = u'%s_to_public' % self.review_type
subject = u'Mozilla Add-ons: %s %s Fully Reviewed'
if not self.addon.is_listed:
template = u'unlisted_to_reviewed'
if auto_validation:
template = u'unlisted_to_reviewed_auto'
subject = u'Mozilla Add-ons: %s %s signed and ready to download'
self.notify_email(template, subject)
log.info(u'Making %s files %s public' %
(self.addon, ', '.join([f.filename for f in self.files])))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request and not auto_validation:
ReviewerScore.award_points(self.request.user, self.addon, status)
def _give_points(self, user=None, addon=None, status=None):
user = user or self.user
addon = addon or self.addon
ReviewerScore.award_points(user,
addon,
status or addon.status,
version=addon.current_version)
def process_public(self, auto_validation=False):
"""Set an addon to public."""
# Sign addon.
for file_ in self.files:
sign_file(file_, settings.SIGNING_SERVER)
# Hold onto the status before we change it.
status = self.addon.status
# Save files first, because set_addon checks to make sure there
# is at least one public file or it won't make the addon public.
self.set_files(amo.STATUS_PUBLIC, self.files, copy_to_mirror=True)
self.set_addon(status=amo.STATUS_PUBLIC)
self.log_action(amo.LOG.APPROVE_VERSION)
template = u'%s_to_public' % self.review_type
subject = u'Mozilla Add-ons: %s %s Approved'
if not self.addon.is_listed:
template = u'unlisted_to_reviewed'
if auto_validation:
template = u'unlisted_to_reviewed_auto'
subject = u'Mozilla Add-ons: %s %s signed and ready to download'
self.notify_email(template, subject)
log.info(u'Making %s public' % (self.addon))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request and not auto_validation:
ReviewerScore.award_points(self.request.user, self.addon, status)
def process_public(self):
"""Set an addon to public."""
assert not self.version or (
self.version.channel == amo.RELEASE_CHANNEL_LISTED)
# Sign addon.
for file_ in self.files:
sign_file(file_, settings.SIGNING_SERVER)
# Hold onto the status before we change it.
status = self.addon.status
# Save files first, because set_addon checks to make sure there
# is at least one public file or it won't make the addon public.
self.set_files(amo.STATUS_PUBLIC, self.files, copy_to_mirror=True)
self.set_addon(status=amo.STATUS_PUBLIC)
self.log_action(amo.LOG.APPROVE_VERSION)
template = u'%s_to_public' % self.review_type
subject = u'Mozilla Add-ons: %s %s Approved'
self.notify_email(template, subject)
log.info(u'Making %s public' % (self.addon))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(self.request.user, self.addon, status)
def process_preliminary(self, auto_validation=False):
"""Set an addon to preliminary."""
# Sign addon.
for file_ in self.files:
sign_file(file_, settings.PRELIMINARY_SIGNING_SERVER)
# Hold onto the status before we change it.
status = self.addon.status
changes = {'status': amo.STATUS_LITE}
template = u'%s_to_preliminary' % self.review_type
subject = u'Mozilla Add-ons: %s %s Preliminary Reviewed'
if (self.review_type == 'preliminary'
and self.addon.status == amo.STATUS_LITE_AND_NOMINATED):
template = u'nominated_to_nominated'
if not self.addon.is_listed:
template = u'unlisted_to_reviewed'
if auto_validation:
template = u'unlisted_to_reviewed_auto'
subject = u'Mozilla Add-ons: %s %s signed and ready to download'
self.set_addon(**changes)
self.set_files(amo.STATUS_LITE, self.files, copy_to_mirror=True)
self.log_action(amo.LOG.PRELIMINARY_VERSION)
self.notify_email(template, subject)
log.info(u'Making %s preliminary' % (self.addon))
log.info(u'Sending email for %s' % (self.addon))
if self.request and not auto_validation:
# Assign reviewer incentive scores.
ReviewerScore.award_points(self.request.user, self.addon, status)
def process_public(self):
"""Set an addons files to public."""
assert not self.version or (
self.version.channel == amo.RELEASE_CHANNEL_LISTED)
# Sign addon.
for file_ in self.files:
sign_file(file_, settings.SIGNING_SERVER)
# Hold onto the status before we change it.
status = self.addon.status
self.set_files(amo.STATUS_PUBLIC, self.files)
self.log_action(amo.LOG.APPROVE_VERSION)
template = u'%s_to_public' % self.review_type
subject = u'Mozilla Add-ons: %s %s Approved'
self.notify_email(template, subject)
log.info(u'Making %s files %s public' %
(self.addon, ', '.join([f.filename for f in self.files])))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(self.request.user, self.addon, status)
def eventlog_detail(request, id):
log = get_object_or_404(ActivityLog.objects.editor_events(), pk=id)
review = None
# I really cannot express the depth of the insanity incarnate in
# our logging code...
if len(log.arguments) > 1 and isinstance(log.arguments[1], Review):
review = log.arguments[1]
is_admin = acl.action_allowed(request, 'ReviewerAdminTools', 'View')
can_undelete = review and review.deleted and (
is_admin or request.user.pk == log.user.pk)
if request.method == 'POST':
# A Form seems overkill for this.
if request.POST['action'] == 'undelete':
if not can_undelete:
raise PermissionDenied
ReviewerScore.award_moderation_points(
log.user, review.addon, review.id, undo=True)
review.undelete()
return redirect('editors.eventlog.detail', id)
data = context(request, log=log, can_undelete=can_undelete)
return render(request, 'editors/eventlog_detail.html', data)
def process_sandbox(self):
"""Set an addon back to sandbox."""
# Hold onto the status before we change it.
status = self.addon.status
if (not self.is_upgrade or
not self.addon.versions.exclude(id=self.version.id)
.filter(files__status__in=amo.REVIEWED_STATUSES)):
self.set_addon(status=amo.STATUS_NULL)
else:
self.set_addon(status=amo.STATUS_LITE)
self.set_files(amo.STATUS_DISABLED, self.files,
hide_disabled_file=True)
self.log_action(amo.LOG.REJECT_VERSION)
template = u'%s_to_sandbox' % self.review_type
subject = u'Mozilla Add-ons: %s %s didn\'t pass review'
if not self.addon.is_listed:
template = u'unlisted_to_sandbox'
subject = u'Mozilla Add-ons: %s %s didn\'t pass review'
self.notify_email(template, subject)
log.info(u'Making %s disabled' % (self.addon))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(self.request.user, self.addon, status)
def process_public(self):
"""Set an addons files to public."""
assert not self.version or (
self.version.channel == amo.RELEASE_CHANNEL_LISTED)
# Sign addon.
for file_ in self.files:
sign_file(file_, settings.SIGNING_SERVER)
# Hold onto the status before we change it.
status = self.addon.status
self.set_files(amo.STATUS_PUBLIC, self.files)
self.log_action(amo.LOG.APPROVE_VERSION)
template = u'%s_to_public' % self.review_type
subject = u'Mozilla Add-ons: %s %s Approved'
self.notify_email(template, subject)
log.info(u'Making %s files %s public' %
(self.addon, ', '.join([f.filename for f in self.files])))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(self.request.user, self.addon, status)
def delete(self, user_responsible=None):
if user_responsible is None:
user_responsible = self.user
review_was_moderated = False
# Log deleting reviews to moderation log,
# except if the author deletes it
if user_responsible != self.user:
# Remember moderation state
review_was_moderated = True
from olympia.editors.models import ReviewerScore
activity.log_create(
amo.LOG.DELETE_REVIEW, self.addon, self, user=user_responsible,
details=dict(
title=unicode(self.title),
body=unicode(self.body),
addon_id=self.addon.pk,
addon_title=unicode(self.addon.name),
is_flagged=self.reviewflag_set.exists()))
for flag in self.reviewflag_set.all():
flag.delete()
log.info(u'Review deleted: %s deleted id:%s by %s ("%s": "%s")',
user_responsible.name, self.pk, self.user.name,
unicode(self.title), unicode(self.body))
self.update(deleted=True)
# Force refreshing of denormalized data (it wouldn't happen otherwise
# because we're not dealing with a creation).
self.update_denormalized_fields()
if (review_was_moderated):
ReviewerScore.award_moderation_points(user_responsible,
self.addon,
self.pk)
def process_sandbox(self):
"""Set an addon or a version back to sandbox."""
# Safeguard to force implementation for unlisted add-ons to completely
# override this method.
assert self.version.channel == amo.RELEASE_CHANNEL_LISTED
# Hold onto the status before we change it.
status = self.addon.status
if self.set_addon_status:
self.set_addon(status=amo.STATUS_NULL)
self.set_files(amo.STATUS_DISABLED, self.files,
hide_disabled_file=True)
self.log_action(amo.LOG.REJECT_VERSION)
template = u'%s_to_sandbox' % self.review_type
subject = u'Mozilla Add-ons: %s %s didn\'t pass review'
self.notify_email(template, subject)
self.log_sandbox_message()
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(
self.request.user, self.addon, status, version=self.version)
def process_public(self, auto_validation=False):
"""Set an addons files to public."""
if self.review_type == 'preliminary':
raise AssertionError('Preliminary addons cannot be made public.')
# Sign addon.
for file_ in self.files:
sign_file(file_, settings.SIGNING_SERVER)
# Hold onto the status before we change it.
status = self.addon.status
self.set_files(amo.STATUS_PUBLIC, self.files, copy_to_mirror=True)
self.log_action(amo.LOG.APPROVE_VERSION)
template = u'%s_to_public' % self.review_type
subject = u'Mozilla Add-ons: %s %s Fully Reviewed'
if not self.addon.is_listed:
template = u'unlisted_to_reviewed'
if auto_validation:
template = u'unlisted_to_reviewed_auto'
subject = u'Mozilla Add-ons: %s %s signed and ready to download'
self.notify_email(template, subject)
log.info(u'Making %s files %s public' %
(self.addon, ', '.join([f.filename for f in self.files])))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request and not auto_validation:
ReviewerScore.award_points(self.request.user, self.addon, status)
def process_preliminary(self, auto_validation=False):
"""Set an addons files to preliminary."""
# Sign addon.
for file_ in self.files:
sign_file(file_, settings.PRELIMINARY_SIGNING_SERVER)
# Hold onto the status before we change it.
status = self.addon.status
self.set_files(amo.STATUS_LITE, self.files, copy_to_mirror=True)
self.log_action(amo.LOG.PRELIMINARY_VERSION)
template = u'%s_to_preliminary' % self.review_type
subject = u'Mozilla Add-ons: %s %s Preliminary Reviewed'
if not self.addon.is_listed:
template = u'unlisted_to_reviewed'
if auto_validation:
template = u'unlisted_to_reviewed_auto'
subject = u'Mozilla Add-ons: %s %s signed and ready to download'
self.notify_email(template, subject)
log.info(u'Making %s files %s preliminary' %
(self.addon, ', '.join([f.filename for f in self.files])))
log.info(u'Sending email for %s' % (self.addon))
if self.request and not auto_validation:
# Assign reviewer incentive scores.
ReviewerScore.award_points(self.request.user, self.addon, status)
def process_sandbox(self):
"""Set an addon or a version back to sandbox."""
# Safeguard to force implementation for unlisted add-ons to completely
# override this method.
assert self.version.channel == amo.RELEASE_CHANNEL_LISTED
# Hold onto the status before we change it.
status = self.addon.status
if self.set_addon_status:
self.set_addon(status=amo.STATUS_NULL)
self.set_files(amo.STATUS_DISABLED,
self.files,
hide_disabled_file=True)
self.log_action(amo.LOG.REJECT_VERSION)
template = u'%s_to_sandbox' % self.review_type
subject = u'Mozilla Add-ons: %s %s didn\'t pass review'
self.notify_email(template, subject)
self.log_sandbox_message()
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(self.request.user,
self.addon,
status,
version=self.version)
def eventlog_detail(request, id):
log = get_object_or_404(ActivityLog.objects.editor_events(), pk=id)
review = None
# I really cannot express the depth of the insanity incarnate in
# our logging code...
if len(log.arguments) > 1 and isinstance(log.arguments[1], Review):
review = log.arguments[1]
is_admin = acl.action_allowed(request, 'ReviewerAdminTools', 'View')
can_undelete = review and review.deleted and (is_admin or request.user.pk
== log.user.pk)
if request.method == 'POST':
# A Form seems overkill for this.
if request.POST['action'] == 'undelete':
if not can_undelete:
raise PermissionDenied
ReviewerScore.award_moderation_points(log.user,
review.addon,
review.id,
undo=True)
review.undelete()
return redirect('editors.eventlog.detail', id)
data = context(request, log=log, can_undelete=can_undelete)
return render(request, 'editors/eventlog_detail.html', data)
def test_get_leaderboards(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
self._give_points()
self._give_points(status=amo.STATUS_LITE)
self._give_points(user=user2, status=amo.STATUS_NOMINATED)
leaders = ReviewerScore.get_leaderboards(self.user)
eq_(leaders['user_rank'], 1)
eq_(leaders['leader_near'], [])
eq_(leaders['leader_top'][0]['rank'], 1)
eq_(leaders['leader_top'][0]['user_id'], self.user.id)
eq_(
leaders['leader_top'][0]['total'],
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL] +
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_PRELIM])
eq_(leaders['leader_top'][1]['rank'], 2)
eq_(leaders['leader_top'][1]['user_id'], user2.id)
eq_(leaders['leader_top'][1]['total'],
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL])
self._give_points(
user=user2, addon=amo.tests.addon_factory(type=amo.ADDON_PERSONA))
leaders = ReviewerScore.get_leaderboards(self.user,
addon_type=amo.ADDON_PERSONA)
eq_(len(leaders['leader_top']), 1)
eq_(leaders['leader_top'][0]['user_id'], user2.id)
def reviewers_score_bar(context, types=None, addon_type=None):
user = context.get('user')
return new_context(dict(
request=context.get('request'),
amo=amo, settings=settings,
points=ReviewerScore.get_recent(user, addon_type=addon_type),
total=ReviewerScore.get_total(user),
**ReviewerScore.get_leaderboards(user, types=types,
addon_type=addon_type)))
def reviewers_score_bar(context, types=None, addon_type=None):
user = context.get('user')
return new_context(dict(
request=context.get('request'),
amo=amo, settings=settings,
points=ReviewerScore.get_recent(user, addon_type=addon_type),
total=ReviewerScore.get_total(user),
**ReviewerScore.get_leaderboards(user, types=types,
addon_type=addon_type)))
def test_get_total(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
self._give_points()
self._give_points(status=amo.STATUS_LITE)
self._give_points(user=user2, status=amo.STATUS_NOMINATED)
assert ReviewerScore.get_total(self.user) == (
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL] +
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_PRELIM])
assert ReviewerScore.get_total(user2) == (
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL])
def test_get_total(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
self._give_points()
self._give_points(status=amo.STATUS_PUBLIC)
self._give_points(user=user2, status=amo.STATUS_NOMINATED)
assert ReviewerScore.get_total(
self.user) == (amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL] +
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_UPDATE])
assert ReviewerScore.get_total(user2) == (
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL])
def test_get_total(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
self._give_points()
self._give_points(status=amo.STATUS_LITE)
self._give_points(user=user2, status=amo.STATUS_NOMINATED)
eq_(
ReviewerScore.get_total(self.user),
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL] +
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_PRELIM])
eq_(ReviewerScore.get_total(user2),
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL])
def process_public(self):
"""Set an add-on or a version to public."""
# Safeguard to force implementation for unlisted add-ons to completely
# override this method.
assert self.version.channel == amo.RELEASE_CHANNEL_LISTED
# Safeguard to make sure this action is not used for content review
# (it should use confirm_auto_approved instead).
assert not self.content_review_only
# Sign addon.
for file_ in self.files:
sign_file(file_, settings.SIGNING_SERVER)
# Hold onto the status before we change it.
status = self.addon.status
# Save files first, because set_addon checks to make sure there
# is at least one public file or it won't make the addon public.
self.set_files(amo.STATUS_PUBLIC, self.files)
if self.set_addon_status:
self.set_addon(status=amo.STATUS_PUBLIC)
# If we've approved a webextension, add a tag identifying them as such.
if any(file_.is_webextension for file_ in self.files):
Tag(tag_text='firefox57').save_tag(self.addon)
# If we've approved a mozilla signed add-on, add the firefox57 tag
if all(file_.is_mozilla_signed_extension for file_ in self.files):
Tag(tag_text='firefox57').save_tag(self.addon)
# Increment approvals counter if we have a request (it means it's a
# human doing the review) otherwise reset it as it's an automatic
# approval.
if self.request:
AddonApprovalsCounter.increment_for_addon(addon=self.addon)
else:
AddonApprovalsCounter.reset_for_addon(addon=self.addon)
self.log_action(amo.LOG.APPROVE_VERSION)
template = u'%s_to_public' % self.review_type
subject = u'Mozilla Add-ons: %s %s Approved'
self.notify_email(template, subject)
self.log_public_message()
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(self.request.user,
self.addon,
status,
version=self.version)
def moderator_delete(self, user):
from olympia.editors.models import ReviewerScore
amo.log(amo.LOG.DELETE_REVIEW, self.addon, self,
user=user,
details=dict(title=unicode(self.title),
body=unicode(self.body),
addon_id=self.addon.pk,
addon_title=unicode(self.addon.name),
is_flagged=self.reviewflag_set.exists()))
for flag in self.reviewflag_set.all():
flag.delete()
self.delete(user_responsible=user)
ReviewerScore.award_moderation_points(user, self.addon, self.pk)
def themes_commit(request):
ThemeReviewFormset = formset_factory(forms.ThemeReviewForm)
formset = ThemeReviewFormset(request.POST)
scores = []
for form in formset:
try:
lock = ThemeLock.objects.filter(
theme_id=form.data[form.prefix + '-theme'],
reviewer=request.user)
except MultiValueDictKeyError:
# Address off-by-one error caused by management form.
continue
if lock and form.is_valid():
scores.append(form.save())
# Success message.
points = sum(scores)
success = ungettext(
# L10n: {0} is the number of reviews. {1} is the points just earned.
# L10n: {2} is the total number of points the reviewer has overall.
'{0} theme review successfully processed (+{1} points, {2} total).',
'{0} theme reviews successfully processed (+{1} points, {2} total).',
len(scores)).format(len(scores), points,
ReviewerScore.get_total(request.user))
amo.messages.success(request, success)
if 'theme_redirect_url' in request.session:
return redirect(request.session['theme_redirect_url'])
else:
return redirect(reverse('editors.themes.queue_themes'))
def themes_commit(request):
ThemeReviewFormset = formset_factory(forms.ThemeReviewForm)
formset = ThemeReviewFormset(request.POST)
scores = []
for form in formset:
try:
lock = ThemeLock.objects.filter(theme_id=form.data[form.prefix +
'-theme'],
reviewer=request.user)
except MultiValueDictKeyError:
# Address off-by-one error caused by management form.
continue
if lock and form.is_valid():
scores.append(form.save())
# Success message.
points = sum(scores)
success = ungettext(
# L10n: {0} is the number of reviews. {1} is the points just earned.
# L10n: {2} is the total number of points the reviewer has overall.
'{0} theme review successfully processed (+{1} points, {2} total).',
'{0} theme reviews successfully processed (+{1} points, {2} total).',
len(scores)).format(len(scores), points,
ReviewerScore.get_total(request.user))
amo.messages.success(request, success)
if 'theme_redirect_url' in request.session:
return redirect(request.session['theme_redirect_url'])
else:
return redirect(reverse('editors.themes.queue_themes'))
def process_public(self):
"""Set an add-on or a version to public."""
# Safeguard to force implementation for unlisted add-ons to completely
# override this method.
assert self.version.channel == amo.RELEASE_CHANNEL_LISTED
# Sign addon.
for file_ in self.files:
sign_file(file_, settings.SIGNING_SERVER)
# Hold onto the status before we change it.
status = self.addon.status
# Save files first, because set_addon checks to make sure there
# is at least one public file or it won't make the addon public.
self.set_files(amo.STATUS_PUBLIC, self.files)
if self.set_addon_status:
self.set_addon(status=amo.STATUS_PUBLIC)
# If we've approved a webextension, add a tag identifying them as such.
if any(file_.is_webextension for file_ in self.files):
Tag(tag_text='firefox57').save_tag(self.addon)
# If we've approved a mozilla signed add-on, add the firefox57 tag
if all(file_.is_mozilla_signed_extension for file_ in self.files):
Tag(tag_text='firefox57').save_tag(self.addon)
# Increment approvals counter if we have a request (it means it's a
# human doing the review) otherwise reset it as it's an automatic
# approval.
if self.request:
AddonApprovalsCounter.increment_for_addon(addon=self.addon)
else:
AddonApprovalsCounter.reset_for_addon(addon=self.addon)
self.log_action(amo.LOG.APPROVE_VERSION)
template = u'%s_to_public' % self.review_type
subject = u'Mozilla Add-ons: %s %s Approved'
self.notify_email(template, subject)
self.log_public_message()
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(
self.request.user, self.addon, status, version=self.version)
def save(self):
action = self.cleaned_data['action']
comment = self.cleaned_data.get('comment')
reject_reason = self.cleaned_data.get('reject_reason')
theme = self.cleaned_data['theme']
is_rereview = (
theme.rereviewqueuetheme_set.exists() and
theme.addon.status not in (amo.STATUS_PENDING,
amo.STATUS_REVIEW_PENDING))
theme_lock = ThemeLock.objects.get(theme=self.cleaned_data['theme'])
mail_and_log = True
if action == rvw.ACTION_APPROVE:
if is_rereview:
approve_rereview(theme)
theme.addon.update(status=amo.STATUS_PUBLIC)
theme.approve = datetime.datetime.now()
theme.save()
elif action in (rvw.ACTION_REJECT, rvw.ACTION_DUPLICATE):
if is_rereview:
reject_rereview(theme)
else:
theme.addon.update(status=amo.STATUS_REJECTED)
elif action == rvw.ACTION_FLAG:
if is_rereview:
mail_and_log = False
else:
theme.addon.update(status=amo.STATUS_REVIEW_PENDING)
elif action == rvw.ACTION_MOREINFO:
if not is_rereview:
theme.addon.update(status=amo.STATUS_REVIEW_PENDING)
if mail_and_log:
send_mail(self.cleaned_data, theme_lock)
# Log.
ActivityLog.create(
amo.LOG.THEME_REVIEW, theme.addon, details={
'theme': theme.addon.name.localized_string,
'action': action,
'reject_reason': reject_reason,
'comment': comment}, user=theme_lock.reviewer)
log.info('%sTheme %s (%s) - %s' % (
'[Rereview] ' if is_rereview else '', theme.addon.name,
theme.id, action))
score = 0
if action in (rvw.ACTION_REJECT, rvw.ACTION_DUPLICATE,
rvw.ACTION_APPROVE):
score = ReviewerScore.award_points(
theme_lock.reviewer, theme.addon, theme.addon.status)
theme_lock.delete()
return score
def save(self):
action = self.cleaned_data['action']
comment = self.cleaned_data.get('comment')
reject_reason = self.cleaned_data.get('reject_reason')
theme = self.cleaned_data['theme']
is_rereview = (
theme.rereviewqueuetheme_set.exists() and
theme.addon.status not in (amo.STATUS_PENDING,
amo.STATUS_REVIEW_PENDING))
theme_lock = ThemeLock.objects.get(theme=self.cleaned_data['theme'])
mail_and_log = True
if action == rvw.ACTION_APPROVE:
if is_rereview:
approve_rereview(theme)
theme.addon.update(status=amo.STATUS_PUBLIC)
theme.approve = datetime.datetime.now()
theme.save()
elif action in (rvw.ACTION_REJECT, rvw.ACTION_DUPLICATE):
if is_rereview:
reject_rereview(theme)
else:
theme.addon.update(status=amo.STATUS_REJECTED)
elif action == rvw.ACTION_FLAG:
if is_rereview:
mail_and_log = False
else:
theme.addon.update(status=amo.STATUS_REVIEW_PENDING)
elif action == rvw.ACTION_MOREINFO:
if not is_rereview:
theme.addon.update(status=amo.STATUS_REVIEW_PENDING)
if mail_and_log:
send_mail(self.cleaned_data, theme_lock)
# Log.
ActivityLog.create(
amo.LOG.THEME_REVIEW, theme.addon, details={
'theme': theme.addon.name.localized_string,
'action': action,
'reject_reason': reject_reason,
'comment': comment}, user=theme_lock.reviewer)
log.info('%sTheme %s (%s) - %s' % (
'[Rereview] ' if is_rereview else '', theme.addon.name,
theme.id, action))
score = 0
if action in (rvw.ACTION_REJECT, rvw.ACTION_DUPLICATE,
rvw.ACTION_APPROVE):
score = ReviewerScore.award_points(
theme_lock.reviewer, theme.addon, theme.addon.status)
theme_lock.delete()
return score
def approve(self, user):
from olympia.editors.models import ReviewerScore
activity.log_create(
amo.LOG.APPROVE_REVIEW, self.addon, self, user=user, details=dict(
title=unicode(self.title),
body=unicode(self.body),
addon_id=self.addon.pk,
addon_title=unicode(self.addon.name),
is_flagged=self.reviewflag_set.exists()))
for flag in self.reviewflag_set.all():
flag.delete()
self.editorreview = False
# We've already logged what we want to log, no need to pass
# user_responsible=user.
self.save()
ReviewerScore.award_moderation_points(user, self.addon, self.pk)
def moderator_approve(self, user):
from olympia.editors.models import ReviewerScore
amo.log(amo.LOG.APPROVE_REVIEW, self.addon, self,
user=user,
details=dict(title=unicode(self.title),
body=unicode(self.body),
addon_id=self.addon.pk,
addon_title=unicode(self.addon.name),
is_flagged=self.reviewflag_set.exists()))
for flag in self.reviewflag_set.all():
flag.delete()
self.editorreview = False
# We've already logged what we want to log, no need to pass
# user_responsible=user.
self.save()
ReviewerScore.award_moderation_points(user, self.addon, self.pk)
def test_get_recent(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
self._give_points()
time.sleep(1) # Wait 1 sec so ordering by created is checked.
self._give_points(status=amo.STATUS_LITE)
self._give_points(user=user2)
scores = ReviewerScore.get_recent(self.user)
eq_(len(scores), 2)
eq_(scores[0].score, amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_PRELIM])
eq_(scores[1].score, amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL])
def save(self):
from olympia.reviews.helpers import user_can_delete_review
for form in self.forms:
if form.cleaned_data and user_can_delete_review(
self.request, form.instance):
action = int(form.cleaned_data['action'])
is_flagged = (form.instance.reviewflag_set.count() > 0)
if action != reviews.REVIEW_MODERATE_SKIP: # Delete flags.
for flag in form.instance.reviewflag_set.all():
flag.delete()
review = form.instance
addon = review.addon
if action == reviews.REVIEW_MODERATE_DELETE:
review.delete()
amo.log(amo.LOG.DELETE_REVIEW,
addon,
review,
details=dict(title=unicode(review.title),
body=unicode(review.body),
addon_id=addon.id,
addon_title=unicode(addon.name),
is_flagged=is_flagged))
if self.request:
ReviewerScore.award_moderation_points(
self.request.user, addon, review.id)
elif action == reviews.REVIEW_MODERATE_KEEP:
review.editorreview = False
review.save()
amo.log(amo.LOG.APPROVE_REVIEW,
addon,
review,
details=dict(title=unicode(review.title),
body=unicode(review.body),
addon_id=addon.id,
addon_title=unicode(addon.name),
is_flagged=is_flagged))
if self.request:
ReviewerScore.award_moderation_points(
self.request.user, addon, review.id)
def test_get_recent(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
self._give_points()
time.sleep(1) # Wait 1 sec so ordering by created is checked.
self._give_points(status=amo.STATUS_LITE)
self._give_points(user=user2)
scores = ReviewerScore.get_recent(self.user)
eq_(len(scores), 2)
eq_(scores[0].score, amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_PRELIM])
eq_(scores[1].score, amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL])
def test_no_admins_or_staff_in_leaderboards(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
self._give_points()
self._give_points(status=amo.STATUS_PUBLIC)
self._give_points(user=user2, status=amo.STATUS_NOMINATED)
leaders = ReviewerScore.get_leaderboards(self.user)
assert leaders['user_rank'] == 1
assert leaders['leader_near'] == []
assert leaders['leader_top'][0]['user_id'] == self.user.id
assert len(leaders['leader_top']) == 1 # Only the editor is here.
assert user2.id not in [l['user_id'] for l in leaders['leader_top']], (
'Unexpected admin user found in leaderboards.')
def test_get_recent(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
self._give_points()
time.sleep(1) # Wait 1 sec so ordering by created is checked.
self._give_points(status=amo.STATUS_PUBLIC)
self._give_points(user=user2)
scores = ReviewerScore.get_recent(self.user)
assert len(scores) == 2
assert scores[0].score == (
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_UPDATE])
assert scores[1].score == (
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL])
def test_get_recent(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
self._give_points()
time.sleep(1) # Wait 1 sec so ordering by created is checked.
self._give_points(status=amo.STATUS_PUBLIC)
self._give_points(user=user2)
scores = ReviewerScore.get_recent(self.user)
assert len(scores) == 2
assert scores[0].score == (
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_UPDATE])
assert scores[1].score == (
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL])
def test_no_admins_or_staff_in_leaderboards(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
self._give_points()
self._give_points(status=amo.STATUS_LITE)
self._give_points(user=user2, status=amo.STATUS_NOMINATED)
leaders = ReviewerScore.get_leaderboards(self.user)
assert leaders['user_rank'] == 1
assert leaders['leader_near'] == []
assert leaders['leader_top'][0]['user_id'] == self.user.id
assert len(leaders['leader_top']) == 1 # Only the editor is here.
assert user2.id not in [l['user_id'] for l in leaders['leader_top']], (
'Unexpected admin user found in leaderboards.')
def reject_multiple_versions(self):
"""Reject a list of versions."""
# self.version and self.files won't point to the versions we want to
# modify in this action, so set them to None before finding the right
# versions.
status = self.addon.status
latest_version = self.version
self.version = None
self.files = None
action_id = (amo.LOG.REJECT_CONTENT
if self.content_review_only else amo.LOG.REJECT_VERSION)
for version in self.data['versions']:
files = version.files.all()
self.set_files(amo.STATUS_DISABLED, files, hide_disabled_file=True)
self.log_action(action_id, version=version, files=files)
self.addon.update_status()
self.data['version_numbers'] = u', '.join(
unicode(v.version) for v in self.data['versions'])
# Send the email to the developer. We need to pass the latest version
# of the add-on instead of one of the versions we rejected, it will be
# used to generate a token allowing the developer to reply, and that
# only works with the latest version.
template = u'reject_multiple_versions'
subject = (u"Mozilla Add-ons: One or more versions of %s%s didn't "
u"pass review")
self.notify_email(template, subject, version=latest_version)
log.info(u'Making %s versions %s disabled' % (self.addon, u', '.join(
unicode(v.pk) for v in self.data['versions'])))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(self.request.user,
self.addon,
status,
version=latest_version,
post_review=True,
content_review=self.content_review_only)
def process_sandbox(self):
"""Set an addon back to sandbox."""
assert not self.version or (
self.version.channel == amo.RELEASE_CHANNEL_LISTED)
# Hold onto the status before we change it.
status = self.addon.status
self.set_addon(status=amo.STATUS_NULL)
self.set_files(amo.STATUS_DISABLED, self.files,
hide_disabled_file=True)
self.log_action(amo.LOG.REJECT_VERSION)
template = u'%s_to_sandbox' % self.review_type
subject = u'Mozilla Add-ons: %s %s didn\'t pass review'
self.notify_email(template, subject)
log.info(u'Making %s disabled' % (self.addon))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(self.request.user, self.addon, status)
def save(self):
from olympia.reviews.helpers import user_can_delete_review
for form in self.forms:
if form.cleaned_data and user_can_delete_review(self.request,
form.instance):
action = int(form.cleaned_data['action'])
is_flagged = (form.instance.reviewflag_set.count() > 0)
if action != reviews.REVIEW_MODERATE_SKIP: # Delete flags.
for flag in form.instance.reviewflag_set.all():
flag.delete()
review = form.instance
addon = review.addon
if action == reviews.REVIEW_MODERATE_DELETE:
review.delete()
amo.log(amo.LOG.DELETE_REVIEW, addon, review,
details=dict(title=unicode(review.title),
body=unicode(review.body),
addon_id=addon.id,
addon_title=unicode(addon.name),
is_flagged=is_flagged))
if self.request:
ReviewerScore.award_moderation_points(
self.request.user, addon, review.id)
elif action == reviews.REVIEW_MODERATE_KEEP:
review.editorreview = False
review.save()
amo.log(amo.LOG.APPROVE_REVIEW, addon, review,
details=dict(title=unicode(review.title),
body=unicode(review.body),
addon_id=addon.id,
addon_title=unicode(addon.name),
is_flagged=is_flagged))
if self.request:
ReviewerScore.award_moderation_points(
self.request.user, addon, review.id)
def process_sandbox(self):
"""Set an addon back to sandbox."""
assert not self.version or (
self.version.channel == amo.RELEASE_CHANNEL_LISTED)
# Hold onto the status before we change it.
status = self.addon.status
self.set_addon(status=amo.STATUS_NULL)
self.set_files(amo.STATUS_DISABLED, self.files,
hide_disabled_file=True)
self.log_action(amo.LOG.REJECT_VERSION)
template = u'%s_to_sandbox' % self.review_type
subject = u'Mozilla Add-ons: %s %s didn\'t pass review'
self.notify_email(template, subject)
log.info(u'Making %s disabled' % (self.addon))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(self.request.user, self.addon, status)
def test_get_leaderboards(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
self._give_points()
self._give_points(status=amo.STATUS_LITE)
self._give_points(user=user2, status=amo.STATUS_NOMINATED)
leaders = ReviewerScore.get_leaderboards(self.user)
assert leaders['user_rank'] == 1
assert leaders['leader_near'] == []
assert leaders['leader_top'][0]['rank'] == 1
assert leaders['leader_top'][0]['user_id'] == self.user.id
assert leaders['leader_top'][0]['total'] == (
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL] +
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_PRELIM])
assert leaders['leader_top'][1]['rank'] == 2
assert leaders['leader_top'][1]['user_id'] == user2.id
assert leaders['leader_top'][1]['total'] == (
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL])
self._give_points(
user=user2, addon=amo.tests.addon_factory(type=amo.ADDON_PERSONA))
leaders = ReviewerScore.get_leaderboards(
self.user, addon_type=amo.ADDON_PERSONA)
assert len(leaders['leader_top']) == 1
assert leaders['leader_top'][0]['user_id'] == user2.id
def delete(self, user_responsible=None):
if user_responsible is None:
user_responsible = self.user
review_was_moderated = False
# Log deleting reviews to moderation log,
# except if the author deletes it
if user_responsible != self.user:
# Remember moderation state
review_was_moderated = True
from olympia.editors.models import ReviewerScore
activity.log_create(amo.LOG.DELETE_REVIEW,
self.addon,
self,
user=user_responsible,
details=dict(
title=unicode(self.title),
body=unicode(self.body),
addon_id=self.addon.pk,
addon_title=unicode(self.addon.name),
is_flagged=self.reviewflag_set.exists()))
for flag in self.reviewflag_set.all():
flag.delete()
log.info(u'Review deleted: %s deleted id:%s by %s ("%s": "%s")',
user_responsible.name, self.pk, self.user.name,
unicode(self.title), unicode(self.body))
self.update(deleted=True)
# Force refreshing of denormalized data (it wouldn't happen otherwise
# because we're not dealing with a creation).
self.update_denormalized_fields()
if (review_was_moderated):
ReviewerScore.award_moderation_points(user_responsible, self.addon,
self.pk)
def test_get_leaderboards_last(self):
users = []
for i in range(6):
users.append(UserProfile.objects.create(username='******' % i))
last_user = users.pop(len(users) - 1)
for u in users:
self._give_points(user=u)
# Last user gets lower points by reviewing a persona.
addon = self.addon
addon.type = amo.ADDON_PERSONA
self._give_points(user=last_user, addon=addon)
leaders = ReviewerScore.get_leaderboards(last_user)
assert leaders['user_rank'] == 6
assert len(leaders['leader_top']) == 3
assert len(leaders['leader_near']) == 2
def test_get_leaderboards(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
self._give_points()
self._give_points(status=amo.STATUS_PUBLIC)
self._give_points(user=user2, status=amo.STATUS_NOMINATED)
leaders = ReviewerScore.get_leaderboards(self.user)
assert leaders['user_rank'] == 1
assert leaders['leader_near'] == []
assert leaders['leader_top'][0]['rank'] == 1
assert leaders['leader_top'][0]['user_id'] == self.user.id
assert leaders['leader_top'][0]['total'] == (
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL] +
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_UPDATE])
assert leaders['leader_top'][1]['rank'] == 2
assert leaders['leader_top'][1]['user_id'] == user2.id
assert leaders['leader_top'][1]['total'] == (
amo.REVIEWED_SCORES[amo.REVIEWED_ADDON_FULL])
self._give_points(
user=user2, addon=amo.tests.addon_factory(type=amo.ADDON_PERSONA))
leaders = ReviewerScore.get_leaderboards(self.user,
addon_type=amo.ADDON_PERSONA)
assert len(leaders['leader_top']) == 1
assert leaders['leader_top'][0]['user_id'] == user2.id
def process_sandbox(self):
"""Set an addons files to sandbox."""
# Hold onto the status before we change it.
status = self.addon.status
self.set_files(amo.STATUS_DISABLED, self.files,
hide_disabled_file=True)
self.log_action(amo.LOG.REJECT_VERSION)
template = u'%s_to_sandbox' % self.review_type
subject = u'Mozilla Add-ons: %s %s didn\'t pass review'
if not self.addon.is_listed:
template = u'unlisted_to_sandbox'
subject = u'Mozilla Add-ons: %s %s didn\'t pass review'
self.notify_email(template, subject)
log.info(u'Making %s files %s disabled' %
(self.addon,
', '.join([f.filename for f in self.files])))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(self.request.user, self.addon, status)
def process_sandbox(self):
"""Set an addons files to sandbox."""
# Hold onto the status before we change it.
status = self.addon.status
self.set_files(amo.STATUS_DISABLED,
self.files,
hide_disabled_file=True)
self.log_action(amo.LOG.REJECT_VERSION)
template = u'%s_to_sandbox' % self.review_type
subject = u'Mozilla Add-ons: %s %s didn\'t pass review'
if not self.addon.is_listed:
template = u'unlisted_to_sandbox'
subject = u'Mozilla Add-ons: %s %s didn\'t pass review'
self.notify_email(template, subject)
log.info(u'Making %s files %s disabled' %
(self.addon, ', '.join([f.filename for f in self.files])))
log.info(u'Sending email for %s' % (self.addon))
# Assign reviewer incentive scores.
if self.request:
ReviewerScore.award_points(self.request.user, self.addon, status)
def test_get_leaderboards_last(self):
users = []
for i in range(6):
users.append(UserProfile.objects.create(username='******' % i))
last_user = users.pop(len(users) - 1)
for u in users:
self._give_points(user=u)
# Last user gets lower points by reviewing a persona.
addon = self.addon
addon.type = amo.ADDON_PERSONA
self._give_points(user=last_user, addon=addon)
leaders = ReviewerScore.get_leaderboards(last_user)
assert leaders['user_rank'] == 6
assert len(leaders['leader_top']) == 3
assert len(leaders['leader_near']) == 2
def test_all_users_by_score(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
amo.REVIEWED_LEVELS[0]['points'] = 180
self._give_points()
self._give_points(status=amo.STATUS_LITE)
self._give_points(user=user2, status=amo.STATUS_NOMINATED)
users = ReviewerScore.all_users_by_score()
eq_(len(users), 2)
# First user.
eq_(users[0]['total'], 180)
eq_(users[0]['user_id'], self.user.id)
eq_(users[0]['level'], amo.REVIEWED_LEVELS[0]['name'])
# Second user.
eq_(users[1]['total'], 120)
eq_(users[1]['user_id'], user2.id)
eq_(users[1]['level'], '')
def test_all_users_by_score(self):
user2 = UserProfile.objects.get(email='*****@*****.**')
amo.REVIEWED_LEVELS[0]['points'] = 180
self._give_points()
self._give_points(status=amo.STATUS_LITE)
self._give_points(user=user2, status=amo.STATUS_NOMINATED)
users = ReviewerScore.all_users_by_score()
assert len(users) == 2
# First user.
assert users[0]['total'] == 180
assert users[0]['user_id'] == self.user.id
assert users[0]['level'] == amo.REVIEWED_LEVELS[0]['name']
# Second user.
assert users[1]['total'] == 120
assert users[1]['user_id'] == user2.id
assert users[1]['level'] == ''
def leaderboard(request):
return render(request, 'editors/leaderboard.html', context(
request, scores=ReviewerScore.all_users_by_score()))
def _give_points(self, user=None, addon=None, status=None):
user = user or self.user
addon = addon or self.addon
ReviewerScore.award_points(user, addon, status or addon.status)
def check_event(self, type, status, event, **kwargs):
self.addon.type = type
assert ReviewerScore.get_event(self.addon, status, **kwargs) == event
def test_caching(self):
self._give_points()
with self.assertNumQueries(1):
ReviewerScore.get_total(self.user)
with self.assertNumQueries(0):
ReviewerScore.get_total(self.user)
with self.assertNumQueries(1):
ReviewerScore.get_recent(self.user)
with self.assertNumQueries(0):
ReviewerScore.get_recent(self.user)
with self.assertNumQueries(1):
ReviewerScore.get_leaderboards(self.user)
with self.assertNumQueries(0):
ReviewerScore.get_leaderboards(self.user)
with self.assertNumQueries(1):
ReviewerScore.get_breakdown(self.user)
with self.assertNumQueries(0):
ReviewerScore.get_breakdown(self.user)
# New points invalidates all caches.
self._give_points()
with self.assertNumQueries(1):
ReviewerScore.get_total(self.user)
with self.assertNumQueries(1):
ReviewerScore.get_recent(self.user)
with self.assertNumQueries(1):
ReviewerScore.get_leaderboards(self.user)
with self.assertNumQueries(1):
ReviewerScore.get_breakdown(self.user)
def test_award_moderation_points(self):
ReviewerScore.award_moderation_points(self.user, self.addon, 1)
score = ReviewerScore.objects.all()[0]
assert score.score == (
amo.REVIEWED_SCORES.get(amo.REVIEWED_ADDON_REVIEW))
assert score.note_key == amo.REVIEWED_ADDON_REVIEW
