def test_contributors_get_aware_datetime():
"""Get an aware datetime from a valid string."""
iso_datetime = make_aware(parse_datetime("2016-01-24T23:15:22+0000"),
tz=pytz.utc)
# Test ISO 8601 datetime.
assert iso_datetime == get_aware_datetime("2016-01-24T23:15:22+0000",
tz=pytz.utc)
# Test git-like datetime.
assert iso_datetime == get_aware_datetime("2016-01-24 23:15:22 +0000",
tz=pytz.utc)
# Test just an ISO 8601 date.
iso_datetime = make_aware(parse_datetime("2016-01-24T00:00:00+0000"),
tz=pytz.utc)
assert iso_datetime == get_aware_datetime("2016-01-24", tz=pytz.utc)
# Test None.
assert get_aware_datetime(None) is None
# Test empty string.
assert get_aware_datetime("") is None
# Test non-empty string.
with pytest.raises(ArgumentTypeError):
get_aware_datetime("THIS FAILS")
# Test blank string.
with pytest.raises(ArgumentTypeError):
get_aware_datetime(" ")
def test_cmd_contributors(capfd, dummy_contributors,
default_contributors_kwargs, contributors_kwargs):
"""Contributors across the site."""
result_kwargs = default_contributors_kwargs.copy()
result_kwargs.update(contributors_kwargs)
cmd_args = []
for k in ["project", "language"]:
if result_kwargs["%s_codes" % k]:
for arg in result_kwargs["%s_codes" % k]:
cmd_args.extend(["--%s" % k, arg])
for k in ["since", "until"]:
if result_kwargs[k]:
cmd_args.extend(
["--%s" % k,
result_kwargs[k]])
result_kwargs[k] = make_aware(parse_datetime(result_kwargs[k]))
if result_kwargs["sort_by"]:
cmd_args.extend(["--sort-by", result_kwargs["sort_by"]])
call_command('contributors', *cmd_args)
out, err = capfd.readouterr()
assert out.strip() == str(
"\n".join(
"%s (%s contributions)" % (k, v)
for k, v
in result_kwargs.items()))
def _get_revision_from_since(self, since):
from pootle.core.dateparse import parse_datetime
from pootle.core.utils.timezone import make_aware
from pootle_statistics.models import Submission
if " " in since:
since = "%sT%s%s" % tuple(since.split(" "))
since = make_aware(parse_datetime(since))
submissions_qs = Submission.objects.filter(creation_time__lt=since)
if self.projects:
submissions_qs = submissions_qs.filter(
translation_project__project__code__in=self.projects,
)
if self.languages:
submissions_qs = submissions_qs.filter(
translation_project__language__code__in=self.languages,
)
submission = submissions_qs.last()
if submission is None:
return 0
return submission.unit.revision
def toggle_qualitycheck(self, check_id, false_positive, user):
check = self.qualitycheck_set.get(id=check_id)
if check.false_positive == false_positive:
return
self.revision = Revision.incr()
self.save(
reviewed_by=user)
check.false_positive = false_positive
check.save()
# create submission
old_value = MUTED
new_value = UNMUTED
if false_positive:
old_value = UNMUTED
new_value = MUTED
update_time = make_aware(timezone.now())
sub = Submission(
creation_time=update_time,
translation_project=self.store.translation_project,
submitter=user,
field=SubmissionFields.NONE,
unit=self,
type=SubmissionTypes.WEB,
old_value=old_value,
new_value=new_value,
quality_check=check)
sub.save()
def get_file_mtime(self):
disk_mtime = datetime.datetime.fromtimestamp(self.file.getpomtime()[0])
# set microsecond to 0 for comparing with a time value without
# microseconds
disk_mtime = make_aware(disk_mtime.replace(microsecond=0))
return disk_mtime
def save(self):
comment = self.comment
comment.submit_date = make_aware(datetime.now())
comment.save()
comment_was_saved.send(
sender=comment.__class__,
comment=comment)
def add(self, unit, translation, user=None):
"""Adds a new suggestion to the unit.
:param translation: suggested translation text
:param user: user who is making the suggestion. If it's ``None``,
the ``system`` user will be used.
:return: a tuple ``(suggestion, created)`` where ``created`` is a
boolean indicating if the suggestion was successfully added.
If the suggestion already exists it's returned as well.
"""
dont_add = (
not filter(None, translation)
or translation == unit.target)
if dont_add:
return (None, False)
user = user or User.objects.get_system_user()
pending = SuggestionState.objects.get(name="pending")
try:
suggestion = Suggestion.objects.pending().get(
unit=unit,
user=user,
target_f=translation)
return (suggestion, False)
except Suggestion.DoesNotExist:
suggestion = Suggestion.objects.create(
unit=unit,
user=user,
state_id=pending.id,
target=translation,
creation_time=make_aware(timezone.now()))
return (suggestion, True)
def get_date_interval(month):
from pootle.core.utils.timezone import make_aware
now = start = end = timezone.now()
default_month = start.strftime('%Y-%m')
if month is None:
month = default_month
try:
month_datetime = datetime.strptime(month, '%Y-%m')
except ValueError:
month_datetime = datetime.strptime(default_month, '%Y-%m')
start = make_aware(month_datetime)
if start < now:
if start.month != now.month or start.year != now.year:
end = get_max_month_datetime(start)
else:
end = start
start = start.replace(hour=0, minute=0, second=0)
end = end.replace(hour=23, minute=59, second=59, microsecond=999999)
return [start, end]
def toggle_qualitycheck(self, check_id, false_positive, user):
check = self.qualitycheck_set.get(id=check_id)
if check.false_positive == false_positive:
return
check.false_positive = false_positive
check.save()
self._log_user = user
if false_positive:
self._save_action = MUTE_QUALITYCHECK
else:
self._save_action = UNMUTE_QUALITYCHECK
# create submission
if false_positive:
sub_type = SubmissionTypes.MUTE_CHECK
else:
sub_type = SubmissionTypes.UNMUTE_CHECK
sub = Submission(creation_time=make_aware(timezone.now()),
translation_project=self.store.translation_project,
submitter=user, field=SubmissionFields.NONE,
unit=self, store=self.store, type=sub_type,
quality_check=check)
sub.save()
# update timestamp
# log user action
self.save()
def test_make_aware_use_tz_false(settings):
"""Tests datetimes are left intact if `USE_TZ` is not in effect."""
settings.USE_TZ = False
datetime_object = datetime(2016, 1, 2, 21, 52, 25)
assert timezone.is_naive(datetime_object)
datetime_aware = make_aware(datetime_object)
assert timezone.is_naive(datetime_aware)
def accept_suggestion(self, suggestion, update_unit):
accepted = SuggestionState.objects.get(name="accepted")
suggestion.state_id = accepted.id
suggestion.reviewer = self.reviewer
suggestion.review_time = make_aware(timezone.now())
if update_unit:
self.update_unit_on_accept(suggestion)
suggestion.save()
def test_make_aware(settings):
"""Tests datetimes can be made aware of timezones."""
settings.USE_TZ = True
datetime_object = datetime(2016, 1, 2, 21, 52, 25)
assert timezone.is_naive(datetime_object)
datetime_aware = make_aware(datetime_object)
assert timezone.is_aware(datetime_aware)
def to_datetime(possible_dt):
if possible_dt is None:
return
if isinstance(possible_dt, datetime):
return possible_dt
if isinstance(possible_dt, date):
return make_aware(
datetime.combine(
possible_dt,
datetime.min.time()))
def get_context_data(self, **kwargs):
ctx = super().get_context_data(**kwargs)
now = make_aware(datetime.now())
ctx.update({"now": now.strftime("%Y-%m-%d %H:%M:%S")})
if self.object.rate > 0:
ctx.update({
"paid_task_form": PaidTaskForm(user=self.object),
"paid_task_types": PaidTaskTypes,
})
return ctx
def test_make_aware_explicit_tz(settings):
"""Tests datetimes are made aware of the given timezone."""
settings.USE_TZ = True
given_timezone = pytz.timezone("Asia/Bangkok")
datetime_object = datetime(2016, 1, 2, 21, 52, 25)
assert timezone.is_naive(datetime_object)
datetime_aware = make_aware(datetime_object, tz=given_timezone)
assert timezone.is_aware(datetime_aware)
assert datetime_aware.tzinfo.zone == given_timezone.zone
def test_make_aware_explicit_tz(settings):
"""Tests datetimes are made aware of the given timezone."""
settings.USE_TZ = True
given_timezone = pytz.timezone('Asia/Bangkok')
datetime_object = datetime(2016, 1, 2, 21, 52, 25)
assert timezone.is_naive(datetime_object)
datetime_aware = make_aware(datetime_object, tz=given_timezone)
assert timezone.is_aware(datetime_aware)
assert datetime_aware.tzinfo.zone == given_timezone.zone
def test_make_aware_default_tz(settings):
"""Tests datetimes are made aware of the configured timezone."""
settings.USE_TZ = True
datetime_object = datetime(2016, 1, 2, 21, 52, 25)
assert timezone.is_naive(datetime_object)
datetime_aware = make_aware(datetime_object)
assert timezone.is_aware(datetime_aware)
# Not comparing `tzinfo` directly because that depends on the combination of
# actual date+times
assert datetime_aware.tzinfo.zone == timezone.get_default_timezone().zone
def test_make_aware_default_tz(settings):
"""Tests datetimes are made aware of the configured timezone."""
settings.USE_TZ = True
datetime_object = datetime(2016, 1, 2, 21, 52, 25)
assert timezone.is_naive(datetime_object)
datetime_aware = make_aware(datetime_object)
assert timezone.is_aware(datetime_aware)
# Not comparing `tzinfo` directly because that depends on the combination of
# actual date+times
assert datetime_aware.tzinfo.zone == timezone.get_default_timezone().zone
def sub_unmute_qc(self, **kwargs):
quality_check = kwargs["quality_check"]
submitter = kwargs["submitter"]
_kwargs = dict(creation_time=make_aware(timezone.now()),
submitter=submitter,
field=SubmissionFields.CHECK,
type=SubmissionTypes.WEB,
old_value=MUTED,
new_value=UNMUTED,
quality_check=quality_check)
_kwargs.update(kwargs)
return self.create_submission(**_kwargs)
def calculate(self, start=None, end=None):
if start is None:
start = make_aware(
datetime.combine(
date.today(),
datetime.min.time()))
calculated_scores = {}
scored_events = self.logs.get_events(
user=self.user, start=start, end=end)
for event in scored_events:
self.score_event(event, calculated_scores)
return calculated_scores
def get_aware_datetime(dt_string):
"""Return an aware datetime parsed from a datetime or date string.
Datetime or date string can be any format parsable by dateutil.parser.parse
"""
if not dt_string:
return None
try:
return make_aware(parse_datetime(dt_string))
except ValueError:
raise ArgumentTypeError('The provided datetime/date string is not '
'valid: "%s"' % dt_string)
def get_aware_datetime(dt_string):
"""Return an aware datetime parsed from a datetime or date string.
Datetime or date string can be any format parsable by dateutil.parser.parse
"""
if not dt_string:
return None
try:
return make_aware(parse_datetime(dt_string))
except ValueError:
raise ArgumentTypeError('The provided datetime/date string is not '
'valid: "%s"' % dt_string)
def get_context_data(self, **kwargs):
ctx = super(UserStatsView, self).get_context_data(**kwargs)
now = make_aware(datetime.now())
ctx.update({
'now': now.strftime('%Y-%m-%d %H:%M:%S'),
})
if self.object.rate > 0:
ctx.update({
'paid_task_form': PaidTaskForm(user=self.object),
'paid_task_types': PaidTaskTypes,
})
return ctx
def sub_unmute_qc(self, **kwargs):
quality_check = kwargs["quality_check"]
submitter = kwargs["submitter"]
_kwargs = dict(
creation_time=make_aware(timezone.now()),
submitter=submitter,
field=SubmissionFields.CHECK,
type=SubmissionTypes.WEB,
old_value=MUTED,
new_value=UNMUTED,
quality_check=quality_check)
_kwargs.update(kwargs)
return self.create_submission(**_kwargs)
def get_context_data(self, **kwargs):
ctx = super(UserStatsView, self).get_context_data(**kwargs)
now = make_aware(datetime.now())
ctx.update({
'now': now.strftime('%Y-%m-%d %H:%M:%S'),
})
if self.object.rate > 0:
ctx.update({
'paid_task_form': PaidTaskForm(user=self.object),
'paid_task_types': PaidTaskTypes,
})
return ctx
def reject_suggestion(self, suggestion):
store = suggestion.unit.store
suggestion.state_id = self.states["rejected"]
suggestion.review_time = make_aware(timezone.now())
suggestion.reviewer = self.reviewer
suggestion.save()
unit = suggestion.unit
if unit.changed:
# if the unit is translated and suggestion was rejected
# set the reviewer info
unit.change.reviewed_by = self.reviewer
unit.change.reviewed_on = suggestion.review_time
unit.change.save()
update_data.send(store.__class__, instance=store)
def get_aware_datetime(dt_string, tz=None):
"""Return an aware datetime parsed from a datetime or date string.
:param dt_string: datetime or date string can be any format parsable by
dateutil.parser.parse.
:param tz: timezone in which `dt_string` should be
considered.
"""
if not dt_string:
return None
try:
return make_aware(parse_datetime(dt_string), tz=tz)
except ValueError:
raise ArgumentTypeError('The provided datetime/date string is not '
'valid: "%s"' % dt_string)
def reject_suggestion(self, suggestion):
store = suggestion.unit.store
rejected = SuggestionState.objects.get(name="rejected")
suggestion.state_id = rejected.id
suggestion.review_time = make_aware(timezone.now())
suggestion.reviewer = self.reviewer
suggestion.save()
unit = suggestion.unit
if unit.changed:
# if the unit is translated and suggestion was rejected
# set the reviewer info
unit.change.reviewed_by = self.reviewer
unit.change.reviewed_on = suggestion.review_time
unit.change.save()
update_data.send(store.__class__, instance=store)
def get_aware_datetime(dt_string, tz=None):
"""Return an aware datetime parsed from a datetime or date string.
:param dt_string: datetime or date string can be any format parsable by
dateutil.parser.parse.
:param tz: timezone in which `dt_string` should be
considered.
"""
if not dt_string:
return None
try:
return make_aware(parse_datetime(dt_string), tz=tz)
except ValueError:
raise ArgumentTypeError('The provided datetime/date string is not '
'valid: "%s"' % dt_string)
def get_date_interval(month):
now = start = end = timezone.now()
if month is None:
month = start.strftime('%Y-%m')
start = make_aware(datetime.strptime(month, '%Y-%m'))
if start < now:
if start.month != now.month or start.year != now.year:
end = get_max_month_datetime(start)
else:
end = start
start = start.replace(hour=0, minute=0, second=0)
end = end.replace(hour=23, minute=59, second=59, microsecond=999999)
return [start, end]
def test_score_store_updater_event(store0, admin, member):
unit0 = store0.units[0]
unit1 = store0.units[1]
today = date.today()
yesterday = today - timedelta(days=1)
class DummyLogs(object):
_start = None
_end = None
_user = None
@property
def _events(self):
return [
LogEvent(unit0, admin, today, "action0", 0),
LogEvent(unit0, admin, yesterday, "action1", 1),
LogEvent(unit1, member, today, "action2", 2)]
def get_events(self, start=None, end=None, user=None, **kwargs):
self._start = start
self._end = end
self._user = user
for event in self._events:
yield event
class DummyScoreUpdater(StoreScoreUpdater):
@cached_property
def logs(self):
return DummyLogs()
updater = DummyScoreUpdater(store0)
result = updater.calculate()
assert updater.logs._start == make_aware(
datetime.combine(today, datetime.min.time()))
assert updater.logs._end is None
assert updater.logs._user is None
# no score adapters
assert result == {}
result = updater.calculate(start=yesterday, end=today)
assert updater.logs._start == yesterday
assert updater.logs._end == today
assert result == {}
updater = DummyScoreUpdater(store0, user=admin)
updater.calculate()
assert updater.logs._user == admin
def get_activity_data(request, user, month):
[start, end] = get_date_interval(month)
json = {}
user_dict = (
{
"id": user.id,
"username": user.username,
"formatted_name": user.formatted_name,
"currency": user.currency if user.currency else CURRENCIES[0][0],
"rate": user.rate,
"review_rate": user.review_rate,
"hourly_rate": user.hourly_rate,
}
if user != ""
else user
)
now = make_aware(datetime.now())
json["meta"] = {
"user": user_dict,
"month": month,
"now": now.strftime("%Y-%m-%d %H:%M:%S"),
"start": start.strftime("%Y-%m-%d"),
"end": end.strftime("%Y-%m-%d"),
"utc_offset": start.strftime("%z"),
"admin_permalink": request.build_absolute_uri(reverse("pootle-reports")),
}
if user != "":
scores = ScoreLog.objects.for_user_in_range(user, start, end)
scores = list(scores.order_by("submission__translation_project"))
json["grouped"] = get_grouped_word_stats(scores, user, month)
scores.sort(key=lambda x: x.creation_time)
json["daily"] = get_daily_activity(user, scores, start, end)
json["summary"] = get_summary(scores, start, end)
tasks = get_paid_tasks(user, start, end)
for task in tasks:
if settings.USE_TZ:
task["datetime"] = timezone.localtime(task["datetime"])
task["datetime"] = task["datetime"].strftime("%Y-%m-%d %H:%M:%S")
json["paid_tasks"] = tasks
return json
def evernote_reports(request):
User = get_user_model()
now = make_aware(datetime.now())
ctx = {
'users': jsonify(map(
lambda x: {'id': x.username, 'text': escape(x.formatted_name)},
User.objects.hide_meta()
)),
'user_rates_form': UserRatesForm(),
'paid_task_form': PaidTaskForm(),
'now': now.strftime('%Y-%m-%d %H:%M:%S'),
'admin_report': True,
'paid_task_types': PaidTaskTypes,
}
return render_to_response('admin/reports.html', ctx,
context_instance=RequestContext(request))
def reports(request):
User = get_user_model()
now = make_aware(datetime.now())
ctx = {
"page": "admin-reports",
"users": [
{"id": x.username, "text": x.formatted_name}
for x in User.objects.hide_meta()
],
"user_rates_form": UserRatesForm(),
"paid_task_form": PaidTaskForm(),
"now": now.strftime("%Y-%m-%d %H:%M:%S"),
"admin_report": True,
"paid_task_types": PaidTaskTypes,
}
return render(request, "admin/reports.html", ctx)
def evernote_reports(request):
User = get_user_model()
now = make_aware(datetime.now())
ctx = {
'users': jsonify(map(
lambda x: {'id': x.username, 'text': escape(x.formatted_name)},
User.objects.hide_meta()
)),
'user_rates_form': UserRatesForm(),
'paid_task_form': PaidTaskForm(),
'now': now.strftime('%Y-%m-%d %H:%M:%S'),
'admin_report': True,
'paid_task_types': PaidTaskTypes,
}
return render_to_response('admin/reports.html', ctx,
context_instance=RequestContext(request))
def reject_suggestion(self, suggestion):
store = suggestion.unit.store
suggestion.state = SuggestionStates.REJECTED
suggestion.review_time = make_aware(timezone.now())
suggestion.reviewer = self.reviewer
suggestion.save()
self.create_submission(suggestion,
SubmissionTypes.SUGG_REJECT,
self.reviewer,
creation_time=suggestion.review_time).save()
unit = suggestion.unit
if unit.changed:
# if the unit is translated and suggestion was rejected
# set the reviewer info
unit.change.reviewed_by = self.reviewer
unit.change.reviewed_on = suggestion.review_time
unit.change.save()
update_data.send(store.__class__, instance=store)
def get_activity_data(request, user, month):
[start, end] = get_date_interval(month)
json = {}
user_dict = {
'id': user.id,
'username': user.username,
'formatted_name': user.formatted_name,
'currency': user.currency if user.currency else CURRENCIES[0][0],
'rate': user.rate,
'review_rate': user.review_rate,
'hourly_rate': user.hourly_rate,
} if user != '' else user
now = make_aware(datetime.now())
json['meta'] = {
'user': user_dict,
'month': month,
'now': now.strftime('%Y-%m-%d %H:%M:%S'),
'start': start.strftime('%Y-%m-%d'),
'end': end.strftime('%Y-%m-%d'),
'utc_offset': start.strftime("%z"),
'admin_permalink': request.build_absolute_uri(
reverse('pootle-reports')),
}
if user != '':
scores = get_scores(user, start, end)
scores = list(scores.order_by(SCORE_TRANSLATION_PROJECT))
json['grouped'] = get_grouped_word_stats(scores, user, month)
scores.sort(key=lambda x: x.creation_time)
json['daily'] = get_daily_activity(user, scores, start, end)
json['summary'] = get_summary(scores, start, end)
tasks = get_paid_tasks(user, start, end)
for task in tasks:
if settings.USE_TZ:
task['datetime'] = timezone.localtime(task['datetime'])
task['datetime'] = task['datetime'].strftime('%Y-%m-%d %H:%M:%S')
json['paid_tasks'] = tasks
return json
def save_unit(self):
user = self.request_user
current_time = make_aware(timezone.now())
updated = []
target = multistring(self.cleaned_data["target_f"] or [u''])
if target != self.unit.target:
self.unit.submitted_by = user
self.unit.submitted_on = current_time
self.unit.reviewed_by = None
self.unit.reviewed_on = None
updated.append(
(SubmissionFields.TARGET,
self.unit.target_f,
self.cleaned_data["target_f"]))
self.unit.target = self.cleaned_data["target_f"]
if self.unit.target:
if self.cleaned_data["is_fuzzy"]:
self.unit.state = FUZZY
else:
self.unit.state = TRANSLATED
else:
self.unit.state = UNTRANSLATED
self.unit.save(
submitted_on=current_time,
submitted_by=user,
changed_with=SubmissionTypes.WEB)
if self.unit.state_updated:
updated.append(
(SubmissionFields.STATE,
self.unit._frozen.state,
self.unit.state))
translation_project = self.unit.store.translation_project
for field, old_value, new_value in updated:
sub = Submission(
creation_time=current_time,
translation_project=translation_project,
submitter=user,
unit=self.unit,
field=field,
type=SubmissionTypes.WEB,
old_value=old_value,
new_value=new_value)
sub.save()
def get_activity_data(request, user, month):
[start, end] = get_date_interval(month)
json = {}
user_dict = {
'id': user.id,
'username': user.username,
'formatted_name': user.formatted_name,
'currency': user.currency if user.currency else CURRENCIES[0][0],
'rate': user.rate,
'review_rate': user.review_rate,
'hourly_rate': user.hourly_rate,
} if user != '' else user
now = make_aware(datetime.now())
json['meta'] = {
'user': user_dict,
'month': month,
'now': now.strftime('%Y-%m-%d %H:%M:%S'),
'start': start.strftime('%Y-%m-%d'),
'end': end.strftime('%Y-%m-%d'),
'utc_offset': start.strftime("%z"),
'admin_permalink': request.build_absolute_uri(
reverse('pootle-reports')),
}
if user != '':
scores = ScoreLog.objects.for_user_in_range(user, start, end)
scores = list(scores.order_by(SCORE_TRANSLATION_PROJECT))
json['grouped'] = get_grouped_word_stats(scores, user, month)
scores.sort(key=lambda x: x.creation_time)
json['daily'] = get_daily_activity(user, scores, start, end)
json['summary'] = get_summary(scores, start, end)
tasks = get_paid_tasks(user, start, end)
for task in tasks:
if settings.USE_TZ:
task['datetime'] = timezone.localtime(task['datetime'])
task['datetime'] = task['datetime'].strftime('%Y-%m-%d %H:%M:%S')
json['paid_tasks'] = tasks
return json
def test_cmd_contributors(capfd, dummy_contributors,
default_contributors_kwargs, contributors_kwargs):
"""Contributors across the site."""
result_kwargs = default_contributors_kwargs.copy()
result_kwargs.update(contributors_kwargs)
cmd_args = []
for k in ["project", "language"]:
if result_kwargs["%s_codes" % k]:
for arg in result_kwargs["%s_codes" % k]:
cmd_args.extend(["--%s" % k, arg])
for k in ["since", "until"]:
if result_kwargs[k]:
cmd_args.extend(["--%s" % k, result_kwargs[k]])
result_kwargs[k] = make_aware(parse_datetime(result_kwargs[k]))
if result_kwargs["sort_by"]:
cmd_args.extend(["--sort-by", result_kwargs["sort_by"]])
call_command('contributors', *cmd_args)
out, err = capfd.readouterr()
assert out.strip() == str("\n".join("%s (%s contributions)" % (k, v)
for k, v in result_kwargs.items()))
def save_unit(self):
current_time = make_aware(timezone.now())
updated = []
if self.cleaned_data["target_f"]:
self.unit.target = self.cleaned_data["target_f"]
self.unit.save(
submitted_on=current_time,
submitted_by=self.target_object.user,
reviewed_on=current_time,
reviewed_by=self.request_user,
changed_with=SubmissionTypes.WEB)
updated.append(
(SubmissionFields.TARGET,
self.unit._frozen.target,
self.unit.target))
if self.unit.state_updated:
updated.append(
(SubmissionFields.STATE,
self.unit._frozen.state,
self.unit.state))
translation_project = self.unit.store.translation_project
for field, old_value, new_value in updated:
sub = Submission(
creation_time=current_time,
translation_project=translation_project,
suggestion=self.target_object,
submitter=self.target_object.user,
unit=self.unit,
field=field,
type=SubmissionTypes.WEB,
old_value=old_value,
new_value=new_value)
sub.save()
self.suggestion_review.accept(
update_unit=(
False
if self.cleaned_data["target_f"]
else True))
def test_score_event_state_updated(store0, admin, settings):
unit = store0.units.first()
scoring = event_score.gather(LogEvent)
scorer = scoring["state_updated"]
assert scorer == scores.StateUpdatedScore
sub = Submission.objects.create(
unit=unit,
submitter=admin,
translation_project=unit.store.translation_project,
creation_time=make_aware(timezone.now()),
old_value=UNTRANSLATED,
new_value=TRANSLATED)
event = LogEvent(
unit, admin, datetime.now(), "example", sub)
score = scorer(event)
assert score.event == event
assert score.unit == unit
assert score.submission == sub
assert (
score.score
== (unit.unit_source.source_wordcount
* settings.POOTLE_SCORES["state_translated"]))
assert score.translated == unit.unit_source.source_wordcount
assert score.reviewed == 0
assert score.suggested == 0
assert (
score.get_score()
== dict(
score=score.score,
translated=unit.unit_source.source_wordcount,
reviewed=0,
suggested=0))
sub = Submission.objects.create(
unit=unit,
submitter=admin,
translation_project=unit.store.translation_project,
creation_time=make_aware(timezone.now()),
old_value=FUZZY,
new_value=TRANSLATED)
event = LogEvent(
unit, admin, datetime.now(), "example", sub)
score = scorer(event)
assert score.event == event
assert score.unit == unit
assert score.submission == sub
assert (
score.score
== (unit.unit_source.source_wordcount
* settings.POOTLE_SCORES["state_unfuzzy"]))
assert score.translated == 0
assert score.reviewed == unit.unit_source.source_wordcount
assert score.suggested == 0
assert (
score.get_score()
== dict(
score=score.score,
translated=0,
reviewed=unit.unit_source.source_wordcount,
suggested=0))
sub = Submission.objects.create(
unit=unit,
submitter=admin,
translation_project=unit.store.translation_project,
creation_time=make_aware(timezone.now()),
old_value=TRANSLATED,
new_value=FUZZY)
event = LogEvent(
unit, admin, datetime.now(), "example", sub)
score = scorer(event)
assert score.event == event
assert score.unit == unit
assert score.submission == sub
assert (
score.score
== (unit.unit_source.source_wordcount
* settings.POOTLE_SCORES["state_fuzzy"]))
assert score.translated == 0
assert score.reviewed == unit.unit_source.source_wordcount
assert score.suggested == 0
assert (
score.get_score()
== dict(
score=score.score,
translated=0,
reviewed=unit.unit_source.source_wordcount,
suggested=0))
def save(self):
comment = self.comment
comment.user = self.cleaned_data["user"]
comment.submit_date = make_aware(datetime.now())
comment.save()
comment_was_saved.send(sender=comment.__class__, comment=comment)
def handle_unit_pre_save(**kwargs):
unit = kwargs["instance"]
auto_translated = False
was_fuzzy = unit._frozen.state == FUZZY
sysuser = get_user_model().objects.get_system_user()
if unit.source_updated:
# update source related fields
unit.source_hash = md5(unit.source_f.encode("utf-8")).hexdigest()
unit.source_length = len(unit.source_f)
wc = unit.update_wordcount()
if not wc and not bool(filter(None, unit.target_f.strings)):
# auto-translate untranslated strings
unit.target = unit.source
unit.state = FUZZY
auto_translated = True
if unit.target_updated:
# update target related fields
unit.target_wordcount = unit.counter.count_words(
unit.target_f.strings)
unit.target_length = len(unit.target_f)
if filter(None, unit.target_f.strings):
if unit.state == UNTRANSLATED:
unit.state = TRANSLATED
else:
# if it was TRANSLATED then set to UNTRANSLATED
if unit.state > FUZZY:
unit.state = UNTRANSLATED
if was_fuzzy:
# set reviewer data if FUZZY has been removed only and
# translation hasn't been updated
unit.reviewed_on = make_aware(timezone.now())
unit.reviewed_by = unit.reviewed_by or sysuser
elif unit.state == FUZZY:
# clear reviewer data if unit has been marked as FUZZY
unit.reviewed_on = None
unit.reviewed_by = None
elif unit.state == UNTRANSLATED:
# clear reviewer and translator data if translation
# has been deleted
unit.reviewed_on = None
unit.reviewed_by = None
unit.submitted_by = None
unit.submitted_on = None
# Updating unit from the .po file set its revision property to
# a new value (the same for all units during its store updated)
# since that change doesn't require further sync but note that
# auto_translated units require further sync
update_revision = (
unit.revision is None
or (not unit.revision_updated
and (unit.updated and not auto_translated)))
if update_revision:
unit.revision = Revision.incr()
if unit.index is None:
unit.index = unit.store.max_index() + 1
unitid = uniqueid.get(unit.__class__)(unit)
if unitid.changed:
unit.setid(unitid.getid())
def save(self):
comment = self.comment
comment.user = self.request_user
comment.submit_date = make_aware(datetime.now())
comment.save()
comment_was_saved.send(sender=comment.__class__, comment=comment)
def dt_yesterday(yesterday):
return make_aware(datetime.combine(yesterday,
datetime.min.time())).astimezone(
pytz.timezone("UTC"))
def test_score_event_state_updated(store0, admin, settings):
unit = store0.units.first()
scoring = event_score.gather(LogEvent)
scorer = scoring["state_updated"]
assert scorer == scores.StateUpdatedScore
sub = Submission.objects.create(
unit=unit,
submitter=admin,
translation_project=unit.store.translation_project,
creation_time=make_aware(timezone.now()),
old_value=UNTRANSLATED,
new_value=TRANSLATED)
event = LogEvent(
unit, admin, datetime.now(), "example", sub)
score = scorer(event)
assert score.event == event
assert score.unit == unit
assert score.submission == sub
assert (
score.score
== (unit.source_wordcount
* settings.POOTLE_SCORES["state_translated"]))
assert score.translated == unit.source_wordcount
assert score.reviewed == 0
assert score.suggested == 0
assert (
score.get_score()
== dict(
score=score.score,
translated=unit.source_wordcount,
reviewed=0,
suggested=0))
sub = Submission.objects.create(
unit=unit,
submitter=admin,
translation_project=unit.store.translation_project,
creation_time=make_aware(timezone.now()),
old_value=FUZZY,
new_value=TRANSLATED)
event = LogEvent(
unit, admin, datetime.now(), "example", sub)
score = scorer(event)
assert score.event == event
assert score.unit == unit
assert score.submission == sub
assert (
score.score
== (unit.source_wordcount
* settings.POOTLE_SCORES["state_unfuzzy"]))
assert score.translated == 0
assert score.reviewed == unit.source_wordcount
assert score.suggested == 0
assert (
score.get_score()
== dict(
score=score.score,
translated=0,
reviewed=unit.source_wordcount,
suggested=0))
sub = Submission.objects.create(
unit=unit,
submitter=admin,
translation_project=unit.store.translation_project,
creation_time=make_aware(timezone.now()),
old_value=TRANSLATED,
new_value=FUZZY)
event = LogEvent(
unit, admin, datetime.now(), "example", sub)
score = scorer(event)
assert score.event == event
assert score.unit == unit
assert score.submission == sub
assert (
score.score
== (unit.source_wordcount
* settings.POOTLE_SCORES["state_fuzzy"]))
assert score.translated == 0
assert score.reviewed == unit.source_wordcount
assert score.suggested == 0
assert (
score.get_score()
== dict(
score=score.score,
translated=0,
reviewed=unit.source_wordcount,
suggested=0))
class ScoreLogFactory(factory.django.DjangoModelFactory):
creation_time = make_aware(timezone.now())
class Meta(object):
model = "pootle_statistics.ScoreLog"
class SubmissionFactory(factory.django.DjangoModelFactory):
creation_time = make_aware(timezone.now())
class Meta(object):
model = 'pootle_statistics.Submission'
def test_score_store_updater_event_score(store0, admin, member, member2):
unit0 = store0.units[0]
unit1 = store0.units[1]
today = localdate()
import pytz
from pootle.core.utils.timezone import make_aware
dt_today = make_aware(
datetime.combine(
today,
datetime.min.time())).astimezone(
pytz.timezone("UTC"))
yesterday = today - timedelta(days=1)
dt_yesterday = make_aware(
datetime.combine(
yesterday,
datetime.min.time())).astimezone(
pytz.timezone("UTC"))
class DummyLogs(object):
_start = None
_end = None
@cached_property
def _events(self):
return [
LogEvent(unit0, admin, dt_yesterday, "action0", 0),
LogEvent(unit0, admin, dt_yesterday, "action1", 1),
LogEvent(unit0, admin, dt_today, "action0", 0),
LogEvent(unit0, member2, dt_today, "action1", 1),
LogEvent(unit0, member, dt_today, "action2", 2),
LogEvent(unit1, member, dt_today, "action2", 3)]
def get_events(self, start=None, end=None, **kwargs):
self._start = start
self._end = end
for event in self._events:
yield event
class DummyScoreUpdater(StoreScoreUpdater):
@cached_property
def logs(self):
return DummyLogs()
updater = DummyScoreUpdater(store0)
result = updater.calculate()
assert result == {}
class DummyScore(object):
def __init__(self, event):
self.event = event
def get_score(self):
return dict(
score=(self.event.value * self.base_score),
translated=(7 * self.base_score),
reviewed=(23 * self.base_score),
suggested=(108 * self.base_score))
class Action0Score(DummyScore):
base_score = 0
class Action1Score(DummyScore):
base_score = 1
class Action2Score(DummyScore):
base_score = 2
def get_score(self):
score = super(Action2Score, self).get_score()
score["reviewed"] = 0
return score
@provider(event_score, sender=LogEvent)
def dummy_event_score_provider(**kwargs_):
return dict(
action0=Action0Score,
action1=Action1Score,
action2=Action2Score)
updater = DummyScoreUpdater(store0)
result = updater.calculate()
assert len(result) == 2
assert len(result[today]) == 2
assert result[today][member.id] == {
'suggested': 432,
'score': 10,
'translated': 28}
assert result[today][member2.id] == {
'suggested': 108,
'score': 1,
'translated': 7,
'reviewed': 23}
assert len(result[yesterday]) == 1
assert result[yesterday][admin.id] == {
'suggested': 108,
'score': 1,
'translated': 7,
'reviewed': 23}
store0.user_scores.all().delete()
updater.update()
mem_score = UserStoreScore.objects.filter(
store=store0, user=member)
assert mem_score.get(date=today).suggested == 432
assert mem_score.get(date=today).score == 10
assert mem_score.get(date=today).translated == 28
assert mem_score.get(date=today).reviewed == 0
today_score = mem_score.get(date=today)
today_score.reviewed = 99999
today_score.score = 0
today_score.save()
updater.update()
assert mem_score.get(date=today).suggested == 432
assert mem_score.get(date=today).score == 10
assert mem_score.get(date=today).translated == 28
assert mem_score.get(date=today).reviewed == 0
