feat: add old snap warning for snaps not updated in 2+ years

- Add is_snap_old() function to detect snaps older than 2 years
- Add convert_date_month_year() for cleaner date formatting
- Display warning notification on snap details for old snaps
- Use simple "Month Year" format for better readability
- Add custom styling with orange left border for consistency
- Include comprehensive test coverage for date logic
- Message: "This snap in this channel hasn't been updated since [Month Year]. Contact the developer to ask for an update."

Fixes #2988

Author: gajeshbhat

static/sass/styles.scss

@@ -273,6 +273,12 @@ dl {
   }
 }
 
+.old-snap-warning {
+  border: none !important;
+  border-radius: 0 !important;
+  box-shadow: none !important;
+}
+
 .snap-published-in-cell {
   @media (max-width: $breakpoint-large - 1) {
     display: none !important;

templates/store/snap-details/_details.html

@@ -19,6 +19,17 @@ <h5 class="p-muted-heading">Last updated</h5>
   <hr>
 {% endif %}
 
+{% if old_snap_info and old_snap_info.is_old %}
+  <div class="p-notification--caution old-snap-warning">
+    <div class="p-notification__content">
+      <p class="p-notification__message">
+        This snap in this channel hasn't been updated since {{ old_snap_info.last_updated_formatted }}. Contact the developer to ask for an update.
+      </p>
+    </div>
+  </div>
+  <hr>
+{% endif %}
+
 {% if links %}
   {% if links["website"] %}
     <h5 class="p-muted-heading">Websites</h5>

tests/store/tests_public_logic.py

@@ -472,3 +472,99 @@ def test_get_last_updated_versions(self):
         self.assertEqual(
             result, [latest_edge["channel"], latest_stable["channel"]]
         )
+
+    def test_is_snap_old_empty_date(self):
+        """Test that empty or None date returns not old"""
+        result = logic.is_snap_old(None)
+        self.assertFalse(result["is_old"])
+        self.assertEqual(result["years_since_update"], 0)
+
+        result = logic.is_snap_old("")
+        self.assertFalse(result["is_old"])
+        self.assertEqual(result["years_since_update"], 0)
+
+    def test_is_snap_old_invalid_date(self):
+        """Test that invalid date returns not old"""
+        result = logic.is_snap_old("invalid-date")
+        self.assertFalse(result["is_old"])
+        self.assertEqual(result["years_since_update"], 0)
+
+    @freeze_time("2024-01-01")
+    def test_is_snap_old_recent_snap(self):
+        """Test that a recently updated snap is not considered old"""
+        recent_date = "2023-06-01T10:00:00Z"
+        result = logic.is_snap_old(recent_date)
+        self.assertFalse(result["is_old"])
+        self.assertEqual(result["years_since_update"], 0)
+        self.assertIn("last_updated_formatted", result)
+
+    @freeze_time("2024-01-02")
+    def test_is_snap_old_exactly_two_years(self):
+        """Test that a snap updated exactly 2 years ago is considered old"""
+        old_date = "2022-01-01T10:00:00Z"
+        result = logic.is_snap_old(old_date)
+        self.assertTrue(result["is_old"])
+        self.assertEqual(result["years_since_update"], 1)
+        self.assertIn("last_updated_formatted", result)
+
+    @freeze_time("2024-01-02")
+    def test_is_snap_old_very_old_snap(self):
+        """Test that a very old snap is considered old"""
+        very_old_date = "2020-01-01T10:00:00Z"
+        result = logic.is_snap_old(very_old_date)
+        self.assertTrue(result["is_old"])
+        self.assertEqual(result["years_since_update"], 4)
+        self.assertIn("last_updated_formatted", result)
+
+    @freeze_time("2024-01-01")
+    def test_is_snap_old_just_under_two_years(self):
+        """Test that a snap updated just under 2 years ago is not old"""
+        almost_old_date = "2022-02-01T10:00:00Z"
+        result = logic.is_snap_old(almost_old_date)
+        self.assertFalse(result["is_old"])
+        self.assertEqual(result["years_since_update"], 1)
+        self.assertIn("last_updated_formatted", result)
+
+    @freeze_time("2024-01-02")
+    def test_is_snap_old_custom_threshold(self):
+        """Test that custom threshold works correctly"""
+        date_one_year_ago = "2023-01-01T10:00:00Z"
+
+        # With default threshold (2 years), should not be old
+        result = logic.is_snap_old(date_one_year_ago)
+        self.assertFalse(result["is_old"])
+
+        # With custom threshold (1 year), should be old
+        result = logic.is_snap_old(date_one_year_ago, old_threshold_years=1)
+        self.assertTrue(result["is_old"])
+        self.assertEqual(result["years_since_update"], 0)  # int(1.003) = 0
+
+    def test_is_snap_old_different_date_formats(self):
+        """Test that different ISO date formats are handled correctly"""
+        # Test with different timezone formats
+        dates_to_test = [
+            "2020-01-01T10:00:00Z",
+            "2020-01-01T10:00:00+00:00",
+            "2020-01-01T10:00:00.000Z",
+            "2020-01-01T10:00:00.123456+00:00",
+        ]
+
+        for date_str in dates_to_test:
+            with freeze_time("2024-01-02"):
+                result = logic.is_snap_old(date_str)
+                self.assertTrue(
+                    result["is_old"], f"Failed for date format: {date_str}"
+                )
+                self.assertEqual(result["years_since_update"], 4)
+
+    def test_convert_date_month_year(self):
+        """Test the month-year date formatting function"""
+        test_cases = [
+            ("2022-01-14T10:00:00Z", "January 2022"),
+            ("2020-12-25T15:30:00Z", "December 2020"),
+            ("2019-06-01T00:00:00Z", "June 2019"),
+        ]
+
+        for date_str, expected in test_cases:
+            result = logic.convert_date_month_year(date_str)
+            self.assertEqual(result, expected, f"Failed for date: {date_str}")

webapp/store/logic.py

@@ -192,16 +192,76 @@ def convert_date(date_to_convert):
     :param date_to_convert: Date to convert
     :returns: Readable date
     """
-    local_timezone = datetime.datetime.utcnow().tzinfo
-    date_parsed = parser.parse(date_to_convert).replace(tzinfo=local_timezone)
-    delta = datetime.datetime.utcnow() - datetime.timedelta(days=1)
+    date_parsed = parser.parse(date_to_convert)
+    # Ensure we have a timezone-aware datetime
+    if date_parsed.tzinfo is None:
+        date_parsed = date_parsed.replace(tzinfo=datetime.timezone.utc)
+
+    now = datetime.datetime.now(datetime.timezone.utc)
+    delta = now - datetime.timedelta(days=1)
 
     if delta < date_parsed:
         return humanize.naturalday(date_parsed).title()
     else:
         return date_parsed.strftime("%-d %B %Y")
 
 
+def convert_date_month_year(date_to_convert):
+    """Convert date to month and year format: Month Year
+
+    Format of date to convert: 2019-01-12T16:48:41.821037+00:00
+    Output: January 2019
+
+    :param date_to_convert: Date to convert
+    :returns: Month and year only
+    """
+    date_parsed = parser.parse(date_to_convert)
+    if date_parsed.tzinfo is None:
+        date_parsed = date_parsed.replace(tzinfo=datetime.timezone.utc)
+
+    return date_parsed.strftime("%B %Y")
+
+
+def is_snap_old(last_updated_date, old_threshold_years=2.0):
+    """Check if a snap is considered 'old' based on its last update date
+
+    A snap is considered old if it hasn't been updated in the specified
+    number of years (default: 2 years).
+
+    :param last_updated_date: The last updated date string in ISO format
+    :param old_threshold_years: Number of years to consider a snap old
+                                (default: 2)
+    :returns: Dictionary with 'is_old' boolean and 'years_since_update'
+              integer
+    """
+    if not last_updated_date:
+        return {"is_old": False, "years_since_update": 0}
+
+    try:
+        date_parsed = parser.parse(last_updated_date)
+        if date_parsed.tzinfo is None:
+            date_parsed = date_parsed.replace(tzinfo=datetime.timezone.utc)
+
+        now = datetime.datetime.now(datetime.timezone.utc)
+
+        days_diff = (now - date_parsed).days
+        years_diff = days_diff / 365.25  # Account for leap years
+        years_since_update = int(years_diff)
+
+        is_old = days_diff >= (old_threshold_years * 365)
+
+        return {
+            "is_old": is_old,
+            "years_since_update": years_since_update,
+            "last_updated_formatted": convert_date_month_year(
+                last_updated_date
+            ),
+        }
+    except (ValueError, TypeError):
+        # If we can't parse the date, assume it's not old
+        return {"is_old": False, "years_since_update": 0}
+
+
 categories_list = [
     "development",
     "games",

webapp/store/snap_details_views.py

@@ -177,6 +177,7 @@ def _get_context_snap_details(snap_name, supported_architectures=None):
             "filesize": humanize.naturalsize(binary_filesize),
             "last_updated": logic.convert_date(last_updated),
             "last_updated_raw": last_updated,
+            "old_snap_info": logic.is_snap_old(last_updated),
             "is_users_snap": is_users_snap,
             "unlisted": details.get("snap", {}).get("unlisted", False),
             "developer": developer,