wip

Author: tudoramariei

backend/donations/views/dashboard/stats_helpers/chart.py

@@ -1,17 +1,26 @@
-from datetime import datetime
-from typing import Dict
+from typing import Dict, Any
 
-from django.core.cache import cache
+from django.conf import settings
 from django.utils.timezone import now
-from django_q.tasks import async_task
 
 from donations.models import Donor
 from donations.views.dashboard.stats_helpers.utils import cache_set
+from redirectioneaza.common.async_cache import async_cache_decorator, is_cache_valid_for_past_date
 
 STATS_FOR_MONTH_CACHE_PREFIX = "STATS_FOR_MONTH_"
 
 
-def donors_for_month(month: int, year: int = None) -> Dict[str, int]:
+@async_cache_decorator(
+    cache_key_custom=f"{STATS_FOR_MONTH_CACHE_PREFIX}{{1}}_{{{0}}}",
+    placeholder_value={
+        "metric": -2,
+        "year": 0,
+        "month": 0,
+    },
+    validation_func=is_cache_valid_for_past_date,
+    timeout=settings.TIMEOUT_CACHE_NORMAL,
+)
+def donors_for_month(month: int, year: int = None) -> Dict[str, Any]:
     """
     Determines the number of donors for a specified month and year.
 
@@ -26,63 +35,41 @@ def donors_for_month(month: int, year: int = None) -> Dict[str, int]:
         year (int, optional): The year for which donor statistics are required or current year.
 
     Returns:
-        Dict[str, int]: A dictionary containing the number of donors for the specified month and year.
+        Dict[str, Any]: A dictionary containing the number of donors for the specified month and year.
     """
-    current_time = now()
-
     if year is None:
-        year = current_time.year
-
-    cache_key = f"{STATS_FOR_MONTH_CACHE_PREFIX}{year}_{month}"
-
-    if cached_stats := cache.get(cache_key):
-        if _is_cache_valid(current_time, month, year):
-            return cached_stats
-
-        cache.delete(cache_key)
-
-    default_stat = {
-        "metric": -2,
-        "year": year,
-        "month": month,
-    }
+        year = now().year
 
-    async_task(
-        _update_stats_for_month,
-        month,
-        year,
-        cache_key,
-    )
+    # This function is decorated with async_cache_decorator, which handles caching and async tasks.
+    # The actual implementation is in _update_stats_for_month, which is called by the decorator.
+    return _update_stats_for_month(month, year)
 
-    return cached_stats or default_stat
 
-
-def _is_cache_valid(current_time: datetime, month: int, year: int) -> bool:
-    if not current_time:
-        return False
-
-    if year < current_time.year:
-        return True
-
-    if month < current_time.month:
-        return True
-
-    return False
-
-
-def _update_stats_for_month(month: int, year: int, cache_key: str) -> Dict[str, int]:
+def _update_stats_for_month(month: int, year: int, _cache_key: str = None, _timeout: int = None) -> Dict[str, Any]:
     """
     Updates the number of donors for a specific month and year, and caches the result.
-    If the cache is valid, it returns the cached number of donors.
+
+    Parameters:
+        month (int): The month for which to compute donor statistics.
+        year (int): The year for which to compute donor statistics.
+        _cache_key (str, optional): The cache key to use when storing the result.
+            This is passed by the async_cache_decorator.
+        _timeout (int, optional): The cache timeout in seconds.
+            This is passed by the async_cache_decorator.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the number of donors for the specified month and year.
     """
     donors_count = Donor.objects.filter(date_created__year=year, date_created__month=month).count()
 
     stat = {
         "metric": donors_count,
         "year": year,
         "month": month,
+        "timestamp": now(),
     }
 
-    cache_set(cache_key, stat)
+    if _cache_key and _timeout is not None:
+        cache_set(_cache_key, stat, timeout=_timeout)
 
     return stat

backend/donations/views/dashboard/stats_helpers/metrics.py

@@ -1,104 +1,208 @@
+from typing import Dict, Any
+
 from django.conf import settings
-from django.core.cache import cache
 from django.utils.timezone import now
-from django_q.tasks import async_task
 
 from donations.models import Donor, Ngo
 from donations.views.dashboard.stats_helpers.utils import cache_set
+from redirectioneaza.common.async_cache import async_cache_decorator
+
+# Cache key prefix for metrics
+METRIC_CACHE_PREFIX = "METRIC_"
 
 
 def _cache_key_for_metric(metric_name: str) -> str:
     """
     Generates a cache key for the given metric name.
     """
-    return f"METRIC_{metric_name.upper()}"
+    return f"{METRIC_CACHE_PREFIX}{metric_name.upper()}"
 
 
-def metrics_cache_decorator(func):
-    """
-    Decorator to cache the metrics functions.
+@async_cache_decorator(
+    cache_key=_cache_key_for_metric("current_year_redirections"),
+    timeout=settings.TIMEOUT_CACHE_NORMAL,
+)
+def current_year_redirections() -> Dict[str, Any]:
     """
+    Returns the number of redirections (donations) for the current year.
 
-    def wrapper(*args, **kwargs):
-        CACHE_KEY = _cache_key_for_metric(func.__name__)
-
-        if cached_result := cache.get(CACHE_KEY):
-            # if the cache has expired (the timestamp is older than TIMEOUT_CACHE_NORMAL),
-            # we delete the cache entry, trigger an async task to recalculate the metric,
-            # and return the cached result; the updated metric will be available in the next request
-            cache_timestamp = cached_result.get("timestamp")
-            if cache_timestamp and (now() - cache_timestamp).total_seconds() > settings.TIMEOUT_CACHE_NORMAL:
-                cache.delete(CACHE_KEY)
-                async_task(func.__name__, *args, **kwargs)
-
-            return cached_result
-        default_result = {
-            "metric": -2,
-            "timestamp": now(),
-        }
-
-        async_task(func.__name__, *args, **kwargs)
+    Returns:
+        Dict[str, Any]: A dictionary containing the metric and timestamp.
+    """
+    return _update_current_year_redirections()
 
-        return default_result
 
-    return wrapper
+def _update_current_year_redirections(_cache_key: str = None, _timeout: int = None) -> Dict[str, Any]:
+    """
+    Updates the number of redirections for the current year and caches the result.
 
+    Parameters:
+        _cache_key (str, optional): The cache key to use when storing the result.
+            This is passed by the async_cache_decorator.
+        _timeout (int, optional): The cache timeout in seconds.
+            This is passed by the async_cache_decorator.
 
-@metrics_cache_decorator
-def current_year_redirections():
+    Returns:
+        Dict[str, Any]: A dictionary containing the metric and timestamp.
+    """
     result = {
         "metric": Donor.available.filter(date_created__year=now().year).count(),
         "timestamp": now(),
     }
 
-    cache_set(_cache_key_for_metric("current_year_redirections"), result)
+    if _cache_key and _timeout is not None:
+        cache_set(_cache_key, result, timeout=_timeout)
 
     return result
 
 
-@metrics_cache_decorator
-def all_redirections():
+@async_cache_decorator(
+    cache_key=_cache_key_for_metric("all_redirections"),
+    timeout=settings.TIMEOUT_CACHE_NORMAL,
+)
+def all_redirections() -> Dict[str, Any]:
+    """
+    Returns the total number of redirections (donations) across all years.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the metric and timestamp.
+    """
+    return _update_all_redirections()
+
+
+def _update_all_redirections(_cache_key: str = None, _timeout: int = None) -> Dict[str, Any]:
+    """
+    Updates the total number of redirections and caches the result.
+
+    Parameters:
+        _cache_key (str, optional): The cache key to use when storing the result.
+            This is passed by the async_cache_decorator.
+        _timeout (int, optional): The cache timeout in seconds.
+            This is passed by the async_cache_decorator.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the metric and timestamp.
+    """
     result = {
         "metric": Donor.available.count(),
         "timestamp": now(),
     }
 
-    cache_set(_cache_key_for_metric("all_redirections"), result)
+    if _cache_key and _timeout is not None:
+        cache_set(_cache_key, result, timeout=_timeout)
 
     return result
 
 
-@metrics_cache_decorator
-def all_active_ngos():
+@async_cache_decorator(
+    cache_key=_cache_key_for_metric("all_active_ngos"),
+    timeout=settings.TIMEOUT_CACHE_NORMAL,
+)
+def all_active_ngos() -> Dict[str, Any]:
+    """
+    Returns the total number of active NGOs.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the metric and timestamp.
+    """
+    return _update_all_active_ngos()
+
+
+def _update_all_active_ngos(_cache_key: str = None, _timeout: int = None) -> Dict[str, Any]:
+    """
+    Updates the total number of active NGOs and caches the result.
+
+    Parameters:
+        _cache_key (str, optional): The cache key to use when storing the result.
+            This is passed by the async_cache_decorator.
+        _timeout (int, optional): The cache timeout in seconds.
+            This is passed by the async_cache_decorator.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the metric and timestamp.
+    """
     result = {
         "metric": Ngo.active.count(),
         "timestamp": now(),
     }
 
-    cache_set(_cache_key_for_metric("all_active_ngos"), result)
+    if _cache_key and _timeout is not None:
+        cache_set(_cache_key, result, timeout=_timeout)
 
     return result
 
 
-@metrics_cache_decorator
-def ngos_active_in_current_year():
+@async_cache_decorator(
+    cache_key=_cache_key_for_metric("ngos_active_in_current_year"),
+    timeout=settings.TIMEOUT_CACHE_NORMAL,
+)
+def ngos_active_in_current_year() -> Dict[str, Any]:
+    """
+    Returns the number of NGOs that are active in the current year.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the metric and timestamp.
+    """
+    return _update_ngos_active_in_current_year()
+
+
+def _update_ngos_active_in_current_year(_cache_key: str = None, _timeout: int = None) -> Dict[str, Any]:
+    """
+    Updates the number of NGOs active in the current year and caches the result.
+
+    Parameters:
+        _cache_key (str, optional): The cache key to use when storing the result.
+            This is passed by the async_cache_decorator.
+        _timeout (int, optional): The cache timeout in seconds.
+            This is passed by the async_cache_decorator.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the metric and timestamp.
+    """
     result = {
         "metric": Ngo.with_forms_this_year.count(),
         "timestamp": now(),
     }
 
-    cache_set(_cache_key_for_metric("ngos_active_in_current_year"), result)
+    if _cache_key and _timeout is not None:
+        cache_set(_cache_key, result, timeout=_timeout)
 
     return result
 
 
-@metrics_cache_decorator
-def ngos_with_ngo_hub():
+@async_cache_decorator(
+    cache_key=_cache_key_for_metric("ngos_with_ngo_hub"),
+    timeout=settings.TIMEOUT_CACHE_NORMAL,
+)
+def ngos_with_ngo_hub() -> Dict[str, Any]:
+    """
+    Returns the number of NGOs that are part of the NGO Hub.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the metric and timestamp.
+    """
+    return _update_ngos_with_ngo_hub()
+
+
+def _update_ngos_with_ngo_hub(_cache_key: str = None, _timeout: int = None) -> Dict[str, Any]:
+    """
+    Updates the number of NGOs with NGO Hub and caches the result.
+
+    Parameters:
+        _cache_key (str, optional): The cache key to use when storing the result.
+            This is passed by the async_cache_decorator.
+        _timeout (int, optional): The cache timeout in seconds.
+            This is passed by the async_cache_decorator.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the metric and timestamp.
+    """
     result = {
         "metric": Ngo.ngo_hub.count(),
         "timestamp": now(),
     }
 
-    cache_set(_cache_key_for_metric("ngos_with_ngo_hub"), result)
+    if _cache_key and _timeout is not None:
+        cache_set(_cache_key, result, timeout=_timeout)
 
     return result

backend/donations/views/dashboard/stats_helpers/utils.py

@@ -1,9 +1,14 @@
 from django.core.cache import cache
 
 
-def cache_set(key: str, value: dict) -> None:
+def cache_set(key: str, value: dict, timeout: int = None) -> None:
     """
     Sets a value in the cache with a specified key.
-    The timeout is set to None, meaning the cache will not expire.
+
+    Parameters:
+        key (str): The cache key.
+        value (dict): The value to cache.
+        timeout (int, optional): The cache timeout in seconds. If None, the cache will not expire.
+            Defaults to None.
     """
-    cache.set(key, value, timeout=None)
+    cache.set(key, value, timeout=timeout)