def test_score_user_updater_calculate(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 = admin.scores.filter(date__gte=(localdate() - timedelta(days=30))) admin_score = round(sum(admin_score.values_list("score", flat=True)), 2) member_score = member.scores.filter(date__gte=(localdate() - timedelta(days=30))) member_score = round(sum(member_score.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 calculate(self, start=localdate(), end=None, **kwargs): scores = self.filter_users( self.tp_score_model.objects.filter( date__gte=(localdate() - timedelta(days=30))), kwargs.get("users")) return scores.order_by("user").values_list( "user").annotate(score=Sum("score"))
def test_user_tp_score_update_rejects(store0, member, member2): # member makes another suggestion then member2 rejects suggestion_text = "made a suggestion!" suggestions = review.get(Suggestion) current_score = member.scores.get(tp=store0.translation_project, date=localdate()) old_score = round(current_score.score, 2) old_suggested = current_score.suggested old_translated = current_score.translated old_reviewed = current_score.reviewed m2_score = member2.scores.get(tp=store0.translation_project, date=localdate()) m2_old_score = round(m2_score.score, 2) m2_suggested = m2_score.suggested m2_translated = m2_score.translated m2_reviewed = m2_score.reviewed unit = store0.units.filter(state=UNTRANSLATED)[0] sugg, added = suggestions().add(unit, suggestion_text, user=member) suggestions([sugg], member2).reject() current_score = member.scores.get(tp=store0.translation_project, date=localdate()) assert round(current_score.score, 2) == old_score assert current_score.reviewed == old_reviewed assert current_score.translated == old_translated assert (current_score.suggested == old_suggested + unit.unit_source.source_wordcount) m2_score = member2.scores.get(tp=store0.translation_project, date=localdate()) assert round(m2_score.score, 2) > m2_old_score assert m2_score.suggested == m2_suggested assert m2_score.translated == m2_translated assert (m2_score.reviewed == m2_reviewed + unit.unit_source.source_wordcount)
def calculate(self, start=localdate(), end=None, **kwargs): scores = self.filter_users( self.tp_score_model.objects.filter(date__gte=(localdate() - timedelta(days=30))), kwargs.get("users")) return scores.order_by("user").values_list("user").annotate( score=Sum("score"))
def _get_unit_data(self, unit): store = unit.store tp = store.translation_project data = {} data["unit_revision"] = unit.revision data["checks"] = list(unit.qualitycheck_set.filter(name="xmltags")) data["store_data"] = { k: getattr(store.data, k) for k in ["translated_words", "critical_checks", "max_unit_revision", "total_words", "pending_suggestions"]} store_score = unit.store.user_scores.get( user__username="******", date=localdate()) data["store_score"] = { k: getattr(store_score, k) for k in ["translated", "suggested", "reviewed", "score"]} tp_score = tp.user_scores.get( user__username="******", date=localdate()) data["tp_score"] = { k: getattr(tp_score, k) for k in ["translated", "suggested", "reviewed", "score"]} data["store_checks_data"] = { cd.name: cd.count for cd in store.check_data.all()} data["tp_checks_data"] = { cd.name: cd.count for cd in tp.check_data.all()} data["tp_data"] = { k: getattr(tp.data, k) for k in ["translated_words", "critical_checks", "max_unit_revision", "total_words", "pending_suggestions"]} data["dir_revision"] = list( store.parent.revisions.filter( key__in=["stats", "checks"])) data["tp_dir_revision"] = list( tp.directory.revisions.filter( key__in=["stats", "checks"])) return data
def test_scores_user(member, system): score_data = scores.get(member.__class__)(member) assert isinstance(score_data, UserScores) assert score_data.ns == "pootle.score.user" assert score_data.sw_version == PootleScoreConfig.version assert score_data.context == member assert score_data.public_score == member.public_score assert (list(score_data.get_scores_by_language(10)) == list( score_data.get_scores(10).order_by("tp__language").values( "tp__language").annotate(Sum("score")))) top_lang = score_data.get_scores_by_language(20).order_by( "score__sum").first() top_lang = Language.objects.get(id=top_lang["tp__language"]) assert (score_data.get_top_language_within(20) == top_lang) assert (score_data.get_language_top_scores(top_lang) == scores.get( Language)(top_lang).top_scorers) top_lang = score_data.get_top_language_within(100) language_scores = score_data.get_language_top_scores(top_lang) for index, user_score in enumerate(language_scores): if user_score['user__username'] == member.username: assert (score_data.get_top_language(100) == (index + 1, top_lang)) break assert (score_data.top_language == score_data.get_top_language(30)) project_directory = Directory.objects.get(pootle_path="/projects/") assert ( score_data.revision == revision.get(Directory)(project_directory).get( key="stats")) assert (score_data.cache_key == ( "%s.%s.%s" % (member.id, localdate(), score_data.revision))) # system gets no rank sys_score_data = scores.get(system.__class__)(system) assert (sys_score_data.top_language == (-1, None))
def cache_key(self): return ( "%s/%s.%s.%s" % (self.context.language.code, self.context.project.code, localdate(), self.revision))
def test_user_tp_score_update_suggestions(store0, member, member2): unit = store0.units.filter(state=UNTRANSLATED)[0] suggestions = review.get(Suggestion) suggestion_text = "made a suggestion!" # member adds a suggestion # score and sugg increase current_score = member.scores.get( tp=store0.translation_project, date=localdate()) old_suggested = current_score.suggested old_score = round(current_score.score, 2) old_suggested = current_score.suggested old_translated = current_score.translated old_reviewed = current_score.reviewed sugg, added = suggestions().add( unit, suggestion_text, user=member) current_score = member.scores.get( tp=store0.translation_project, date=localdate()) assert round(current_score.score, 2) == old_score assert ( current_score.suggested == old_suggested + unit.unit_source.source_wordcount) assert current_score.translated == old_translated assert current_score.reviewed == old_reviewed # member2 reviews members suggestion # score and review increase m2_score = member2.scores.get( tp=store0.translation_project, date=localdate()) old_m2_score = round(m2_score.score, 2) old_m2_suggested = m2_score.suggested old_m2_translated = m2_score.translated old_m2_reviewed = m2_score.reviewed suggestions([sugg], member2).accept() m2_score = member2.scores.get( tp=store0.translation_project, date=localdate()) assert round(m2_score.score, 2) > old_m2_score assert ( m2_score.reviewed == old_m2_reviewed + unit.unit_source.source_wordcount) assert m2_score.suggested == old_m2_suggested assert m2_score.translated == old_m2_translated
def test_scores_project_set(project_set): score_data = scores.get(project_set.__class__)(project_set) assert isinstance(score_data, ProjectSetScores) _test_scores("projects", project_set, score_data) assert (score_data.cache_key == ("%s.%s" % (localdate(), score_data.revision))) qs = score_data.scores_within_days(30) assert score_data.filter_scores(qs) is qs
def test_scores_language(language0): score_data = scores.get(language0.__class__)(language0) assert isinstance(score_data, LanguageScores) _test_scores("language", language0, score_data) assert (score_data.cache_key == ( "%s.%s.%s" % (language0.code, localdate(), score_data.revision))) qs = score_data.scores_within_days(30) assert (list(score_data.filter_scores(qs)) == list( qs.filter(tp__language_id=language0.id)))
def test_scores_project(project0): score_data = scores.get(project0.__class__)(project0) assert isinstance(score_data, ProjectScores) _test_scores("project", project0, score_data) assert (score_data.cache_key == ( "%s.%s.%s" % (project0.code, localdate(), score_data.revision))) qs = score_data.scores_within_days(30) assert (list(score_data.filter_scores(qs)) == list( qs.filter(tp__project_id=project0.id)))
def save_subs(self, subs): subs = list(subs) if not subs: return self.unit.submission_set.bulk_create(subs) update_scores.send(self.unit.store.__class__, instance=self.unit.store, users=[sub.submitter_id for sub in subs], date=localdate(self.unit.mtime))
def test_user_tp_score_update_translated(store0, member, member2): # member translates another unit, by suggesting and # accepting own suggestion # score, suggested and translated increase suggestion_text = "made a suggestion!" suggestions = review.get(Suggestion) current_score = member.scores.get( tp=store0.translation_project, date=localdate()) old_score = round(current_score.score, 2) old_suggested = current_score.suggested old_translated = current_score.translated old_reviewed = current_score.reviewed m2_score = member2.scores.get( tp=store0.translation_project, date=localdate()) m2_old_score = round(m2_score.score, 2) m2_suggested = m2_score.suggested m2_translated = m2_score.translated m2_reviewed = m2_score.reviewed unit = store0.units.filter(state=UNTRANSLATED)[0] sugg, added = suggestions().add( unit, suggestion_text, user=member) suggestions([sugg], member2).accept() current_score = member.scores.get( tp=store0.translation_project, date=localdate()) assert round(current_score.score, 2) > old_score assert current_score.reviewed == old_reviewed assert ( current_score.suggested == old_suggested + unit.unit_source.source_wordcount) assert ( current_score.translated == old_translated + unit.unit_source.source_wordcount) m2_score = member2.scores.get( tp=store0.translation_project, date=localdate()) assert round(m2_score.score, 2) > m2_old_score assert m2_score.suggested == m2_suggested assert m2_score.translated == m2_translated assert ( m2_score.reviewed == m2_reviewed + unit.unit_source.source_wordcount)
def test_scores_tp(tp0): score_data = scores.get(tp0.__class__)(tp0) assert isinstance(score_data, TPScores) _test_scores("tp", tp0, score_data) assert (score_data.cache_key == ("%s/%s.%s.%s" % (tp0.language.code, tp0.project.code, localdate(), score_data.revision))) qs = score_data.scores_within_days(30) assert (list(score_data.filter_scores(qs)) == list( qs.filter(tp_id=tp0.id)))
def handle_submission_added(**kwargs): submission = kwargs["instance"] is_system_user = ( submission.submitter == get_user_model().objects.get_system_user()) if is_system_user: return update_scores.send(submission.unit.store.__class__, instance=submission.unit.store, users=[submission.submitter_id], date=localdate(submission.creation_time))
def test_scores_project_set(project_set): score_data = scores.get(project_set.__class__)(project_set) assert isinstance(score_data, ProjectSetScores) _test_scores("projects", project_set, score_data) assert ( score_data.cache_key == ("%s.%s" % (localdate(), score_data.revision))) qs = score_data.scores_within_days(30) assert score_data.filter_scores(qs) is qs
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 handle_submission_added(**kwargs): submission = kwargs["instance"] is_system_user = ( submission.submitter == get_user_model().objects.get_system_user()) if is_system_user: return update_scores.send( submission.unit.store.__class__, instance=submission.unit.store, users=[submission.submitter_id], date=localdate(submission.creation_time))
def test_user_tp_score_update_suggestions(store0, member, member2): unit = store0.units.filter(state=UNTRANSLATED)[0] suggestions = review.get(Suggestion) suggestion_text = "made a suggestion!" # member adds a suggestion # score and sugg increase current_score = member.scores.get(tp=store0.translation_project, date=localdate()) old_suggested = current_score.suggested old_score = round(current_score.score, 2) old_suggested = current_score.suggested old_translated = current_score.translated old_reviewed = current_score.reviewed sugg, added = suggestions().add(unit, suggestion_text, user=member) current_score = member.scores.get(tp=store0.translation_project, date=localdate()) assert round(current_score.score, 2) == old_score assert (current_score.suggested == old_suggested + unit.unit_source.source_wordcount) assert current_score.translated == old_translated assert current_score.reviewed == old_reviewed # member2 reviews members suggestion # score and review increase m2_score = member2.scores.get(tp=store0.translation_project, date=localdate()) old_m2_score = round(m2_score.score, 2) old_m2_suggested = m2_score.suggested old_m2_translated = m2_score.translated old_m2_reviewed = m2_score.reviewed suggestions([sugg], member2).accept() m2_score = member2.scores.get(tp=store0.translation_project, date=localdate()) assert round(m2_score.score, 2) > old_m2_score assert (m2_score.reviewed == old_m2_reviewed + unit.unit_source.source_wordcount) assert m2_score.suggested == old_m2_suggested assert m2_score.translated == old_m2_translated
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 = admin.scores.filter( date__gte=( localdate() - timedelta(days=30))) admin_score = round(sum( admin_score.values_list( "score", flat=True)), 2) member_score = member.scores.filter( date__gte=( localdate() - timedelta(days=30))) member_score = round(sum( member_score.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 test_score_tp_updater_clear_users(tp0, admin, member): tp_scores = tp0.user_scores.filter(date__gte=localdate() - timedelta(days=30)) updater = TPScoreUpdater(tp0) admin_score = admin.score member_score = member.score member_tp_score = tp_scores.filter(user=member).aggregate( score=Sum('score'))['score'] updater.clear(users=[member.id]) member.refresh_from_db() admin.refresh_from_db() assert admin.score == admin_score assert (round(member.score, 2) == round(member_score - member_tp_score, 2))
def test_scores_project(project0): score_data = scores.get(project0.__class__)(project0) assert isinstance(score_data, ProjectScores) _test_scores("project", project0, score_data) assert ( score_data.cache_key == ("%s.%s.%s" % (project0.code, localdate(), score_data.revision))) qs = score_data.scores_within_days(30) assert ( list(score_data.filter_scores(qs)) == list(qs.filter(tp__project_id=project0.id)))
def test_scores_language(language0): score_data = scores.get(language0.__class__)(language0) assert isinstance(score_data, LanguageScores) _test_scores("language", language0, score_data) assert ( score_data.cache_key == ("%s.%s.%s" % (language0.code, localdate(), score_data.revision))) qs = score_data.scores_within_days(30) assert ( list(score_data.filter_scores(qs)) == list(qs.filter(tp__language_id=language0.id)))
def test_scores_tp(tp0): score_data = scores.get(tp0.__class__)(tp0) assert isinstance(score_data, TPScores) _test_scores("tp", tp0, score_data) assert ( score_data.cache_key == ("%s/%s.%s.%s" % (tp0.language.code, tp0.project.code, localdate(), score_data.revision))) qs = score_data.scores_within_days(30) assert ( list(score_data.filter_scores(qs)) == list(qs.filter(tp_id=tp0.id)))
def score_event(self, event, calculated_scores): if event.action not in self.scoring: return scores = self.scoring[event.action](event).get_score() if not scores or not any(x > 0 for x in scores.values()): return event_date = localdate(event.timestamp) calculated_scores[event_date] = (calculated_scores.get(event_date, {})) calculated_scores[event_date][event.user.id] = ( calculated_scores[event_date].get(event.user.id, {})) for k, score in scores.items(): if not score: continue calculated_scores[event_date][event.user.id][k] = ( calculated_scores[event_date][event.user.id].get(k, 0) + score)
def _test_scores(ns, context, score_data): today = localdate() assert score_data.context == context assert ( score_data.get_daterange(30) == (today - timedelta(days=30), today)) assert score_data.ns == "pootle.score.%s" % ns assert score_data.sw_version == PootleScoreConfig.version assert list(score_data.score_model.order_by("id")) == list( UserTPScore.objects.exclude( user__username__in=User.objects.META_USERS).order_by("id")) assert ( list(score_data.scores_within_days(5)) == list(score_data.score_model.filter( date__range=score_data.get_daterange(5)))) assert ( list(score_data.get_scores(5)) == list(score_data.filter_scores(score_data.scores_within_days(5)))) assert ( list(score_data.get_top_scorers(10)) == list( score_data.get_scores(10).order_by("user__username").values( "user__username", "user__email", "user__full_name").annotate( Sum("score"), Sum("suggested"), Sum("reviewed"), Sum("translated")).filter( score__sum__gt=0).order_by("-score__sum"))) assert ( tuple(score_data.top_scorers) == tuple(score_data.get_top_scorers(30))) assert ( score_data.revision == revision.get(context.directory.__class__)( context.directory).get(key="stats")) score_display = score_data.display() assert isinstance(score_display, TopScoreDisplay) for i, item in enumerate(score_display): data = score_data.top_scorers[i] assert item["public_total_score"] == formatter.number( round(data["score__sum"])) assert isinstance(item["user"], DisplayUser) assert item["user"].username == data["user__username"] assert item["user"].full_name == data["user__full_name"] assert item["user"].email == data["user__email"] score_display = score_data.display(limit=1) assert len(list(score_display)) <= 1
def test_scores_user(member, system): score_data = scores.get(member.__class__)(member) assert isinstance(score_data, UserScores) assert score_data.ns == "pootle.score.user" assert score_data.sw_version == PootleScoreConfig.version assert score_data.context == member assert score_data.public_score == member.public_score assert( list(score_data.get_scores_by_language(10)) == list( score_data.get_scores(10).order_by( "tp__language").values("tp__language").annotate(Sum("score")))) top_lang = score_data.get_scores_by_language(20).order_by("score__sum").first() top_lang = Language.objects.get(id=top_lang["tp__language"]) assert ( score_data.get_top_language_within(20) == top_lang) assert ( score_data.get_language_top_scores(top_lang) == scores.get(Language)(top_lang).top_scorers) top_lang = score_data.get_top_language_within(100) language_scores = score_data.get_language_top_scores(top_lang) for index, user_score in enumerate(language_scores): if user_score['user__username'] == member.username: assert ( score_data.get_top_language(100) == (index + 1, top_lang)) break assert ( score_data.top_language == score_data.get_top_language(30)) project_directory = Directory.objects.get(pootle_path="/projects/") assert ( score_data.revision == revision.get(Directory)( project_directory).get(key="stats")) assert ( score_data.cache_key == ("%s.%s.%s" % (member.id, localdate(), score_data.revision))) # system gets no rank sys_score_data = scores.get(system.__class__)(system) assert ( sys_score_data.top_language == (-1, None))
def test_score_store_updater_event(store0, admin, member): unit0 = store0.units[0] unit1 = store0.units[1] today = localdate() 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, users=None, **kwargs): self._start = start self._end = end self._users = users 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 is None assert updater.logs._end is None assert updater.logs._users is None # no score adapters assert result == {} result = updater.calculate(start=yesterday, end=today) assert updater.logs._start == to_datetime(yesterday) assert updater.logs._end == to_datetime(today) assert result == {} updater = DummyScoreUpdater(store0) updater.calculate(users=(admin, )) assert updater.logs._users == (admin, ) updater.calculate(users=(admin, member)) assert updater.logs._users == (admin, member)
def score_event(self, event, calculated_scores): if event.action not in self.scoring: return scores = self.scoring[event.action](event).get_score() if not scores or not any(x > 0 for x in scores.values()): return event_date = localdate(event.timestamp) calculated_scores[event_date] = ( calculated_scores.get(event_date, {})) calculated_scores[event_date][event.user.id] = ( calculated_scores[event_date].get(event.user.id, {})) for k, score in scores.items(): if not score: continue calculated_scores[event_date][event.user.id][k] = ( calculated_scores[event_date][event.user.id].get(k, 0) + score)
def handle_suggestion_change(**kwargs): suggestion = kwargs["instance"] is_system_user = ( (suggestion.is_pending and (suggestion.user_id == get_user_model().objects.get_system_user().id)) or (not suggestion.is_pending and (suggestion.reviewer_id == get_user_model().objects.get_system_user().id))) if is_system_user: return change_date = (suggestion.review_time if not suggestion.is_pending else suggestion.creation_time) update_scores.send(suggestion.unit.store.__class__, instance=suggestion.unit.store, users=[ suggestion.user_id if suggestion.is_pending else suggestion.reviewer_id ], date=localdate(change_date))
def _test_scores(ns, context, score_data): today = localdate() assert score_data.context == context assert (score_data.get_daterange(30) == (today - timedelta(days=30), today)) assert score_data.ns == "pootle.score.%s" % ns assert score_data.sw_version == PootleScoreConfig.version assert list(score_data.score_model.order_by("id")) == list( UserTPScore.objects.exclude( user__username__in=User.objects.META_USERS).order_by("id")) assert (list(score_data.scores_within_days(5)) == list( score_data.score_model.filter( date__range=score_data.get_daterange(5)))) assert (list(score_data.get_scores(5)) == list( score_data.filter_scores(score_data.scores_within_days(5)))) assert (list(score_data.get_top_scorers(10)) == list( score_data.get_scores(10).order_by("user__username").values( "user__username", "user__email", "user__full_name").annotate( Sum("score"), Sum("suggested"), Sum("reviewed"), Sum("translated")).filter( score__sum__gt=0).order_by("-score__sum"))) assert (tuple(score_data.top_scorers) == tuple( score_data.get_top_scorers(30))) assert (score_data.revision == revision.get(context.directory.__class__)( context.directory).get(key="stats")) score_display = score_data.display() assert isinstance(score_display, TopScoreDisplay) for i, item in enumerate(score_display): data = score_data.top_scorers[i] assert item["public_total_score"] == formatter.number( round(data["score__sum"])) assert isinstance(item["user"], DisplayUser) assert item["user"].username == data["user__username"] assert item["user"].full_name == data["user__full_name"] assert item["user"].email == data["user__email"] score_display = score_data.display(limit=1) assert len(list(score_display)) <= 1
def handle_suggestion_change(**kwargs): suggestion = kwargs["instance"] is_system_user = ( (suggestion.is_pending and (suggestion.user_id == get_user_model().objects.get_system_user().id)) or (not suggestion.is_pending and (suggestion.reviewer_id == get_user_model().objects.get_system_user().id))) if is_system_user: return change_date = ( suggestion.review_time if not suggestion.is_pending else suggestion.creation_time) update_scores.send( suggestion.unit.store.__class__, instance=suggestion.unit.store, users=[ suggestion.user_id if suggestion.is_pending else suggestion.reviewer_id], date=localdate(change_date))
def get_daterange(self, days): now = localdate() return now - timedelta(days), now
def get_daterange(self, days): now = localdate() return now - timedelta(days), now
def cache_key(self): return ("%s/%s.%s.%s" % (self.context.language.code, self.context.project.code, localdate(), self.revision))
def cache_key(self): return ( "%s.%s.%s" % (self.context.id, localdate(), self.revision))
def cache_key(self): return ("%s.%s" % (localdate(), self.revision))
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
def calculate(self, start=localdate(), end=None, **kwargs): return self.filter_users( self.tp_score_model.objects, kwargs.get("users")).order_by("user").values_list("user").annotate( score=Sum("score"))
def cache_key(self): return ( "%s.%s" % (localdate(), self.revision))
def test_localdate(settings): today = localdate() assert today == timezone.localtime(timezone.now()).date() assert (localdate(timezone.now() + timedelta(weeks=1)) == today + timedelta(weeks=1))
def test_localdate(settings): today = localdate() assert today == timezone.localtime(timezone.now()).date() assert ( localdate(timezone.now() + timedelta(weeks=1)) == today + timedelta(weeks=1))
def today(): return localdate()
def today(): return localdate()
def cache_key(self): return ("%s.%s.%s" % (self.context.code, localdate(), self.revision))