Another Step in the Quest to clean up the code base.

src/mahjong_ranking/middleware.py

@@ -1,78 +1,53 @@
-# -*- coding: utf-8 -*-
-"""
-Created on 23.05.2011
-
-@author: christian
-"""
+"""Middleware to defer slow denormalization  at the end of a request."""
 from django.core.cache import cache
+
 from mahjong_ranking import models
 from . import logger, MIN_HANCHANS_FOR_LADDER
 
 
-class DenormalizationUpdateMiddleware(object):
-    """
-    This Class deferres the recalculation for the Otaku XP at the end of a
-    response.
-    """
-    event_queue = set()
-    season_queue = set()
+class DenormalizationUpdateMiddleware(object):  # Ignore PyLintBear (R0903)
+    """To recalculate everything in the queues at the end of a POST request."""
 
-    def process_response(self, request, response):
-        # We only do this in POST request, to speedup the responsetime.
-        if request.method == 'POST':
-            print('event_ranking_queue', cache.get(
-                'event_ranking_queue', set()))
-            print('kyu_dan_ranking_queue', cache.get(
-                'kyu_dan_ranking_queue', set()))
-            print('ladder_ranking_queue', cache.get(
-                'ladder_ranking_queue', set()))
-            queue = cache.get('event_ranking_queue', set())
-            if len(queue) > 0:
-                self.recalculate_event_rankings(queue)
-                cache.set('event_ranking_queue', set(), 360)
+    def process_response(self, request, response):  # Ignore PyLintBear (R0201)
+        """Check and process the recalculation queues on each POST request.
 
-            queue = cache.get('kyu_dan_ranking_queue', set())
-            if len(queue) > 0:
-                self.recalulate_kyu_dan_ranking(queue)
-                cache.set('kyu_dan_ranking_queue', set(), 360)
+        :param request: the django HttpRequest object
+        :param response: the django HttpResponse object
+        :return: the django HttpResponse object
+        """
+        event_queue = set()
+        season_queue = set()
 
-            queue = cache.get('ladder_ranking_queue', set())
-            if len(queue) > 0:
-                self.recalculate_ladder_ranking(queue)
-                cache.set('ladder_ranking_queue', set(), 360)
+        if request.method != 'POST':
+            return response
 
-            for event_id in self.event_queue:
-                self.update_event_placements()
-            for season in self.season_queue:
-                self.update_season_placements()
-
-        return response
-
-    def recalculate_event_rankings(self, queue):
-        # recalculate tournament (event) rankings:
-        for event_id, user_id in queue:
-            ranking = models.EventRanking.objects.get_or_create(
+        event_ranking_queue = cache.get('event_ranking_queue', set())
+        while event_ranking_queue:
+            event_id, user_id = event_ranking_queue.pop()
+            event_ranking = models.EventRanking.objects.get_or_create(
                 event_id=event_id, user_id=user_id)[0]
-            ranking.recalculate()
-            self.event_queue.add(event_id)
-        return queue
+            event_ranking.recalculate()
+            event_queue.add(event_id)
+            cache.set('event_ranking_queue', set(), 360)
 
-    def recalulate_kyu_dan_ranking(self, queue):
-        for user_id, hanchan_start in queue:
-            ranking = models.KyuDanRanking.objects.get_or_create(
+        kyu_dan_ranking_queue = cache.get('kyu_dan_ranking_queue', set())
+        while kyu_dan_ranking_queue:
+            user_id, hanchan_start = kyu_dan_ranking_queue.pop()
+            kyu_dan_ranking = models.KyuDanRanking.objects.get_or_create(
                 user_id=user_id)[0]
-            ranking.recalculate(hanchan_start)
-        return queue
+            kyu_dan_ranking.recalculate(hanchan_start)
+        cache.set('kyu_dan_ranking_queue', set(), 360)
 
-    def recalculate_ladder_ranking(self, queue):
-        for season, user_id in queue:
-            ladder = models.SeasonRanking.objects.get_or_create(
+        ladder_ranking_queue = cache.get('ladder_ranking_queue', set())
+        while ladder_ranking_queue:
+            season, user_id = ladder_ranking_queue.pop()
+            ladder_ranking = models.SeasonRanking.objects.get_or_create(
                 user_id=user_id, season=season)[0]
-            ladder.recalculate()
-            self.season_queue.add(season)
+            ladder_ranking.recalculate()
+            season_queue.add(season)
+        cache.set('ladder_ranking_queue', ladder_ranking_queue, 360)
 
-    def update_event_placements(self):
-        for event_id in self.event_queue:
+        for event_id in event_queue:
             eventranking_set = models.EventRanking.objects.filter(
                 event_id=event_id).order_by('avg_placement', '-avg_score')
             placement = 1
@@ -81,8 +56,7 @@ class DenormalizationUpdateMiddleware(object):
                 placement += 1
                 ranking.save(force_update=True)
 
-    def update_season_placements(self):
-        for season in self.season_queue:
+        for season in season_queue:
             logger.info(u'Recalculate placements for Season %d', season)
             season_rankings = models.SeasonRanking.objects.filter(
                 season=season, hanchan_count__gt=MIN_HANCHANS_FOR_LADDER
@@ -92,3 +66,4 @@ class DenormalizationUpdateMiddleware(object):
                 ranking.placement = placement
                 ranking.save(force_update=True)
                 placement += 1
+        return response