def test_score_tp_updater_update(store0, tp0, admin, member, member2, today,
yesterday, create_score_data):
updater = score_updater.get(TranslationProject)(tp0)
store1 = tp0.stores.exclude(id=store0.id).first()
tp0.user_scores.all().delete()
UserStoreScore.objects.filter(store__translation_project=tp0).delete()
score_updater.get(Store)(store0).set_scores(create_score_data(store0))
score_updater.get(Store)(store1).set_scores(create_score_data(store1))
updater.update()
for user in [admin, member, member2]:
scores_today = tp0.user_scores.get(date=today, user=user)
assert scores_today.score == ((store0.id * user.id) +
(store1.id * user.id))
assert scores_today.suggested == ((2 * store0.id * user.id) +
(2 * store1.id * user.id))
assert scores_today.translated == ((3 * store0.id * user.id) +
(3 * store1.id * user.id))
assert scores_today.reviewed == ((4 * store0.id * user.id) +
(4 * store1.id * user.id))
scores_yesterday = tp0.user_scores.get(date=yesterday, user=user)
assert scores_yesterday.score == ((5 * store0.id * user.id) +
(5 * store1.id * user.id))
assert scores_yesterday.suggested == ((6 * store0.id * user.id) +
(6 * store1.id * user.id))
assert scores_yesterday.translated == ((7 * store0.id * user.id) +
(7 * store1.id * user.id))
assert scores_yesterday.reviewed == ((8 * store0.id * user.id) +
(8 * store1.id * user.id))
def handle(self, **options):
users = (list(get_user_model().objects.filter(
username__in=options["users"]).values_list("pk", flat=True))
if options["users"] else None)
if options["reset"]:
score_updater.get(get_user_model())(users=users).clear()
return
score_updater.get(get_user_model())().refresh_scores(users)
def handle_all(self, **options):
if not self.projects and not self.languages:
users = self.get_users(**options)
if options["reset"]:
score_updater.get(get_user_model())(users=users).clear()
else:
score_updater.get(get_user_model())().refresh_scores(users)
else:
super(Command, self).handle_all(**options)
def handle_all(self, **options):
if not self.projects and not self.languages:
users = self.get_users(**options)
if options["reset"]:
score_updater.get(get_user_model())(users=users).clear()
else:
score_updater.get(get_user_model())().refresh_scores(users)
else:
super(Command, self).handle_all(**options)
def handle(self, **options):
users = (
list(get_user_model().objects.filter(
username__in=options["users"]).values_list("pk", flat=True))
if options["users"]
else None)
if options["reset"]:
score_updater.get(get_user_model())(users=users).clear()
return
score_updater.get(get_user_model())().refresh_scores(users)
def test_score_store_updater(store0, admin):
updater = score_updater.get(Store)(store0)
assert updater.store == store0
assert updater.user is None
assert isinstance(updater, StoreScoreUpdater)
assert isinstance(updater.logs, StoreLog)
assert updater.event_class == LogEvent
assert isinstance(updater.scoring, GatheredDict)
updater = score_updater.get(Store)(store0, user=admin)
assert updater.user == admin
def test_score_store_updater(store0, admin):
updater = score_updater.get(Store)(store0)
assert updater.store == store0
assert updater.user is None
assert isinstance(updater, StoreScoreUpdater)
assert isinstance(updater.logs, StoreLog)
assert updater.event_class == LogEvent
assert isinstance(updater.scoring, GatheredDict)
updater = score_updater.get(Store)(store0, user=admin)
assert updater.user == admin
def merge_submissions(self):
"""Merge submitter attribute on submissions
"""
# Delete orphaned submissions.
self.src_user.submission_set.filter(unit__isnull=True).delete()
score_updater.get(
self.src_user.__class__)(users=[self.src_user.id]).clear()
# Update submitter on submissions
self.src_user.submission_set.update(submitter=self.target_user)
def refresh_scores(self, users=None, existing=None, existing_tps=None):
suppress_tp_scores = keep_data(signals=(update_scores, ),
suppress=(TranslationProject, ))
existing = existing or self.get_store_scores(self.tp)
with bulk_operations(UserTPScore):
with suppress_tp_scores:
with bulk_operations(UserStoreScore):
for store in self.tp.stores.iterator():
score_updater.get(store.__class__)(store).update(
users=users, existing=existing.get(store.id))
self.update(users=users, existing=existing_tps)
def test_score_tp_updater_update(store0, tp0, admin, member, member2):
today = localdate()
yesterday = today - timedelta(days=1)
updater = score_updater.get(TranslationProject)(tp0)
store1 = tp0.stores.exclude(id=store0.id).first()
def _generate_data(store):
data = {}
data[today] = dict()
data[yesterday] = dict()
for user in [admin, member, member2]:
data[today][user.id] = dict(
score=(store.id * user.id),
suggested=(2 * store.id * user.id),
translated=(3 * store.id * user.id),
reviewed=(4 * store.id * user.id))
data[yesterday][user.id] = dict(
score=(5 * store.id * user.id),
suggested=(6 * store.id * user.id),
translated=(7 * store.id * user.id),
reviewed=(8 * store.id * user.id))
return data
tp0.user_scores.all().delete()
UserStoreScore.objects.filter(store__translation_project=tp0).delete()
score_updater.get(Store)(store0).set_scores(_generate_data(store0))
score_updater.get(Store)(store1).set_scores(_generate_data(store1))
updater.update()
for user in [admin, member, member2]:
scores_today = tp0.user_scores.get(date=today, user=user)
assert scores_today.score == (
(store0.id * user.id)
+ (store1.id * user.id))
assert scores_today.suggested == (
(2 * store0.id * user.id)
+ (2 * store1.id * user.id))
assert scores_today.translated == (
(3 * store0.id * user.id)
+ (3 * store1.id * user.id))
assert scores_today.reviewed == (
(4 * store0.id * user.id)
+ (4 * store1.id * user.id))
scores_yesterday = tp0.user_scores.get(date=yesterday, user=user)
assert scores_yesterday.score == (
(5 * store0.id * user.id)
+ (5 * store1.id * user.id))
assert scores_yesterday.suggested == (
(6 * store0.id * user.id)
+ (6 * store1.id * user.id))
assert scores_yesterday.translated == (
(7 * store0.id * user.id)
+ (7 * store1.id * user.id))
assert scores_yesterday.reviewed == (
(8 * store0.id * user.id)
+ (8 * store1.id * user.id))
def refresh_scores(self, users=None, **kwargs):
suppress_user_scores = keep_data(signals=(update_scores, ),
suppress=(get_user_model(), ))
tp_scores = self.get_tp_scores()
with bulk_operations(get_user_model()):
with suppress_user_scores:
for tp in TranslationProject.objects.all():
score_updater.get(tp.__class__)(tp).refresh_scores(
users=users, existing_tps=tp_scores.get(tp.id))
self.update(users=users)
def refresh_scores(self, users=None, **kwargs):
suppress_user_scores = keep_data(
signals=(update_scores, ),
suppress=(get_user_model(), ))
tp_scores = self.get_tp_scores()
with bulk_operations(get_user_model()):
with suppress_user_scores:
for tp in TranslationProject.objects.all():
score_updater.get(tp.__class__)(tp).refresh_scores(
users=users,
existing_tps=tp_scores.get(tp.id))
self.update(users=users)
def refresh_scores(self, users=None, existing=None, existing_tps=None):
suppress_tp_scores = keep_data(
signals=(update_scores, ),
suppress=(TranslationProject, ))
existing = existing or self.get_store_scores(self.tp)
with bulk_operations(UserTPScore):
with suppress_tp_scores:
with bulk_operations(UserStoreScore):
for store in self.tp.stores.iterator():
score_updater.get(store.__class__)(store).update(
users=users,
existing=existing.get(store.id))
self.update(users=users, existing=existing_tps)
def test_score_user_updater(tp0, admin, member):
user_updater = score_updater.get(admin.__class__)
admin.score = -999
admin.save()
member.score = -777
member.save()
assert user_updater == UserScoreUpdater
updater = user_updater(users=[admin, member])
assert updater.users == [admin, member]
result = updater.calculate()
admin_score = round(
sum(admin.scores.values_list("score", flat=True)), 2)
member_score = round(
sum(member.scores.values_list("score", flat=True)), 2)
assert round(dict(result)[admin.pk], 2) == admin_score
assert round(dict(result)[member.pk], 2) == member_score
updater.set_scores(result)
admin.refresh_from_db()
member.refresh_from_db()
assert round(admin.score, 2) == admin_score
assert round(member.score, 2) == member_score
admin.score = -999
admin.save()
updater = user_updater((admin, ))
assert updater.users == (admin, )
result = updater.calculate()
assert round(dict(result)[admin.pk], 2) == admin_score
updater.set_scores(result)
admin.refresh_from_db()
assert round(admin.score, 2) == admin_score
def handle_all_stores(self, translation_project, **options):
users = self.get_users(**options)
updater = score_updater.get(TranslationProject)(translation_project)
if options["reset"]:
updater.clear(users)
else:
updater.refresh_scores(users)
def test_score_user_updater(tp0, admin, member):
user_updater = score_updater.get(admin.__class__)
admin.score = -999
admin.save()
member.score = -777
member.save()
assert user_updater == UserScoreUpdater
updater = user_updater(users=[admin, member])
assert updater.users == [admin, member]
result = updater.calculate()
admin_score = round(sum(admin.scores.values_list("score", flat=True)), 2)
member_score = round(sum(member.scores.values_list("score", flat=True)), 2)
assert round(dict(result)[admin.pk], 2) == admin_score
assert round(dict(result)[member.pk], 2) == member_score
updater.set_scores(result)
admin.refresh_from_db()
member.refresh_from_db()
assert round(admin.score, 2) == admin_score
assert round(member.score, 2) == member_score
admin.score = -999
admin.save()
updater = user_updater((admin, ))
assert updater.users == (admin, )
result = updater.calculate()
assert round(dict(result)[admin.pk], 2) == admin_score
updater.set_scores(result)
admin.refresh_from_db()
assert round(admin.score, 2) == admin_score
def handle_all_stores(self, translation_project, **options):
users = self.get_users(**options)
updater = score_updater.get(TranslationProject)(translation_project)
if options["reset"]:
updater.clear(users)
else:
updater.refresh_scores(users)
def test_score_user_updater_refresh(tp0, admin, member):
user_updater = score_updater.get(admin.__class__)
updater = user_updater((admin, ))
admin_score = admin.score
admin.score = 0
admin.save()
member_score = member.score
member.score = 0
member.save()
updater.refresh_scores()
member.refresh_from_db()
admin.refresh_from_db()
assert admin.score == admin_score
assert member.score == member_score
admin.score = 0
admin.save()
member.score = 0
member.save()
updater.refresh_scores(users=[admin])
member.refresh_from_db()
admin.refresh_from_db()
assert admin.score == admin_score
assert member.score == 0
def handle(self, **options):
users = (list(get_user_model().objects.filter(
username__in=options["users"]).values_list("pk", flat=True))
if options["users"] else None)
if options["reset"]:
score_updater.get(get_user_model())(users=users).clear()
return
for tp in TranslationProject.objects.all():
data_update = update_data_after(tp,
signals=(update_scores, ),
suppress=(tp.__class__, ),
kwargs=dict(users=users))
with data_update:
for store in tp.stores.all():
update_scores.send(store.__class__,
instance=store,
users=users)
def test_refresh_scores_language(capfd, admin, member, language0):
"""Reset and set again scores for a language."""
member.refresh_from_db()
admin.refresh_from_db()
updater = score_updater.get(get_user_model())()
member_score = updater.calculate(users=[member]).first()[1]
admin_score = updater.calculate(users=[admin]).first()[1]
member_scores_count = member.scores.filter(tp__language=language0).count()
admin_scores_count = admin.scores.filter(tp__language=language0).count()
member_store_scores_count = member.store_scores.filter(
store__translation_project__language=language0).count()
admin_store_scores_count = admin.store_scores.filter(
store__translation_project__language=language0).count()
call_command('refresh_scores', '--reset', '--language=language0')
out, err = capfd.readouterr()
member.refresh_from_db()
admin.refresh_from_db()
assert member.score == 0
assert member.scores.filter(
tp__language=language0,
tp__project__disabled=False).count() == 0
assert member.store_scores.filter(
store__translation_project__language=language0,
store__translation_project__project__disabled=False).count() == 0
assert admin.score == 0
assert admin.scores.filter(
tp__language=language0,
tp__project__disabled=False).count() == 0
assert admin.store_scores.filter(
store__translation_project__language=language0,
store__translation_project__project__disabled=False).count() == 0
call_command('refresh_scores', '--language=language0')
out, err = capfd.readouterr()
member.refresh_from_db()
admin.refresh_from_db()
assert round(member.score, 2) == round(member_score, 2)
assert (member.scores.filter(tp__language=language0).count() ==
member_scores_count)
assert (member.store_scores.filter(
store__translation_project__language=language0).count() ==
member_store_scores_count)
assert round(admin.score, 2) == round(admin_score, 2)
assert (admin.scores.filter(tp__language=language0).count() ==
admin_scores_count)
assert (admin.store_scores.filter(
store__translation_project__language=language0).count() ==
admin_store_scores_count)
def test_refresh_scores_language(capfd, admin, member, language0):
"""Reset and set again scores for a language."""
member.refresh_from_db()
admin.refresh_from_db()
updater = score_updater.get(get_user_model())()
member_score = updater.calculate(users=[member]).first()[1]
admin_score = updater.calculate(users=[admin]).first()[1]
member_scores_count = member.scores.filter(tp__language=language0).count()
admin_scores_count = admin.scores.filter(tp__language=language0).count()
member_store_scores_count = member.store_scores.filter(
store__translation_project__language=language0).count()
admin_store_scores_count = admin.store_scores.filter(
store__translation_project__language=language0).count()
call_command('refresh_scores', '--reset', '--language=language0')
out, err = capfd.readouterr()
member.refresh_from_db()
admin.refresh_from_db()
assert member.score == 0
assert member.scores.filter(tp__language=language0,
tp__project__disabled=False).count() == 0
assert member.store_scores.filter(
store__translation_project__language=language0,
store__translation_project__project__disabled=False).count() == 0
assert admin.score == 0
assert admin.scores.filter(tp__language=language0,
tp__project__disabled=False).count() == 0
assert admin.store_scores.filter(
store__translation_project__language=language0,
store__translation_project__project__disabled=False).count() == 0
call_command('refresh_scores', '--language=language0')
out, err = capfd.readouterr()
member.refresh_from_db()
admin.refresh_from_db()
assert round(member.score, 2) == round(member_score, 2)
assert (member.scores.filter(
tp__language=language0).count() == member_scores_count)
assert (member.store_scores.filter(
store__translation_project__language=language0).count() ==
member_store_scores_count)
assert round(admin.score, 2) == round(admin_score, 2)
assert (admin.scores.filter(
tp__language=language0).count() == admin_scores_count)
assert (admin.store_scores.filter(
store__translation_project__language=language0).count() ==
admin_store_scores_count)
def clear(self, users=None):
tp_scores = self.score_model.objects.all()
store_scores = self.store_score_model.objects.all()
user_scores = self.user_score_model.objects.all()
if users:
tp_scores = tp_scores.filter(user_id__in=users)
store_scores = store_scores.filter(user_id__in=users)
user_scores = user_scores.filter(id__in=users)
if self.tp:
tp_scores = tp_scores.filter(tp=self.tp)
store_scores = store_scores.filter(
store__translation_project=self.tp)
tp_scores.delete()
store_scores.delete()
user_scores.update(score=0)
user_score_updater = score_updater.get(get_user_model())(users=users)
user_score_updater.update(users=users)
def test_refresh_scores_user_project(capfd, admin, member, project0):
"""Reset and set again scores for particular user in project."""
member.refresh_from_db()
admin.refresh_from_db()
updater = score_updater.get(get_user_model())()
member_score = updater.calculate(users=[member]).first()[1]
admin_score = admin.score
member_scores_count = member.scores.filter(tp__project=project0).count()
admin_scores_count = admin.scores.count()
member_store_scores_count = member.store_scores.filter(
store__translation_project__project=project0).count()
admin_store_scores_count = admin.store_scores.count()
call_command('refresh_scores', '--reset', '--user=member',
'--project=project0')
out, err = capfd.readouterr()
member.refresh_from_db()
admin.refresh_from_db()
assert member.score == 0
assert member.scores.filter(tp__project=project0).count() == 0
assert member.store_scores.filter(
store__translation_project__project=project0).count() == 0
assert admin.score == admin_score
assert admin.scores.count() == admin_scores_count
assert admin.store_scores.count() == admin_store_scores_count
call_command('refresh_scores', '--user=member', '--project=project0')
out, err = capfd.readouterr()
member.refresh_from_db()
admin.refresh_from_db()
assert round(member.score, 2) == round(member_score, 2)
assert (member.scores.filter(
tp__project=project0).count() == member_scores_count)
assert (member.store_scores.filter(
store__translation_project__project=project0).count() ==
member_store_scores_count)
assert round(admin.score, 2) == round(admin_score, 2)
def test_refresh_scores_user_tp(capfd, admin, member, tp0):
"""Reset and set again scores for particular user in TP."""
member.refresh_from_db()
admin.refresh_from_db()
updater = score_updater.get(get_user_model())()
member_score = updater.calculate(users=[member]).first()[1]
admin_score = admin.score
member_scores_count = member.scores.filter(tp=tp0).count()
admin_scores_count = admin.scores.count()
member_store_scores_count = member.store_scores.filter(
store__translation_project=tp0).count()
admin_store_scores_count = admin.store_scores.count()
call_command('refresh_scores', '--reset', '--user=member',
'--project=project0', '--language=language0')
out, err = capfd.readouterr()
member.refresh_from_db()
admin.refresh_from_db()
assert member.score == 0
assert member.scores.filter(tp=tp0).count() == 0
assert member.store_scores.filter(
store__translation_project=tp0).count() == 0
assert admin.score == admin_score
assert admin.scores.count() == admin_scores_count
assert admin.store_scores.count() == admin_store_scores_count
call_command('refresh_scores', '--user=member', '--project=project0',
'--language=language0')
out, err = capfd.readouterr()
member.refresh_from_db()
admin.refresh_from_db()
assert round(member.score, 2) == round(member_score, 2)
assert member.scores.filter(tp=tp0).count() == member_scores_count
assert (member.store_scores.filter(
store__translation_project=tp0).count() ==
member_store_scores_count)
assert round(admin.score, 2) == round(admin_score, 2)
def test_score_tp_updater(tp0, admin, member, member2):
updater = score_updater.get(TranslationProject)(tp0)
assert updater.tp == tp0
assert isinstance(updater, TPScoreUpdater)
def update_store_scores_handler(**kwargs):
store = kwargs["instance"]
score_updater.get(store.__class__)(store).update(
users=kwargs.get("users"),
date=kwargs.get("date"))
def update_tp_scores_handler(**kwargs):
tp = kwargs["instance"]
score_updater.get(tp.__class__)(tp).update(
users=kwargs.get("users"),
date=kwargs.get("date"))
def update_user_scores_handler(**kwargs):
score_updater.get(get_user_model())().update(
users=kwargs.get("users"),
date=kwargs.get("date"))
def update_user_scores_handler(**kwargs):
score_updater.get(get_user_model())().update(users=kwargs.get("users"),
date=kwargs.get("date"))
def update_store_scores_handler(**kwargs):
tp = kwargs["instance"]
score_updater.get(tp.__class__)(tp).update()
def update_tp_scores_handler(**kwargs):
tp = kwargs["instance"]
score_updater.get(tp.__class__)(tp).update(users=kwargs.get("users"),
date=kwargs.get("date"))
def test_score_tp_updater(tp0, admin, member, member2):
updater = score_updater.get(TranslationProject)(tp0)
assert updater.tp == tp0
assert isinstance(updater, TPScoreUpdater)
def update_tp_scores_handler(**kwargs):
store = kwargs["instance"]
score_updater.get(store.__class__)(store).update()
def update_store_scores_handler(**kwargs):
store = kwargs["instance"]
score_updater.get(store.__class__)(store).update(users=kwargs.get("users"),
date=kwargs.get("date"))
def update_user_scores_handler(**kwargs):
users = kwargs.get("users")
score_updater.get(get_user_model())(
users=users).update()
