feat(notifications): add translation activity summary notification

This allows users to follow activity without being overwhelmed with all
the details.

Fixes #13071

Author: nijel

docs/changes.rst

@@ -7,6 +7,7 @@ Weblate 2026.5
 
 * Added :ref:`file_format_params` for :ref:`markdown`, including ``line_max_length``, ``md_extract_code_blocks``, ``md_extract_frontmatter``, and ``md_no_placeholders``.
 * Added :ref:`mdx` support for translating Markdown text while preserving JSX syntax.
+* Added a digest-only translation activity summary notification, see :ref:`notifications`.
 * :ref:`CSV <csv>` and :ref:`XLSX <xlsx>` downloads in :ref:`download` now export plural strings as separate plural-form rows that can be imported back.
 * :ref:`file_format_params` now include ``po_set_language_team``, ``po_set_last_translator``, ``po_set_x_generator``, and ``po_report_msgid_bugs_to`` to control whether Weblate updates the ``Language-Team``, ``Last-Translator``, ``X-Generator``, and ``Report-Msgid-Bugs-To`` headers in Gettext PO and POT files.
 * Added a :ref:`backup-management-command` to run configured backup services synchronously.

docs/user/profile.rst

@@ -170,6 +170,9 @@ example about new strings to translate), while some trigger at component level
 (for example merge errors). These two groups of notifications are visually
 separated in the settings.
 
+The :guilabel:`Translation activity summary` notification is digest-only and
+summarizes added, updated, translated, approved, and unfinished strings.
+
 You can toggle notifications for watched projects and administered projects and it
 can be further tweaked (or muted) per project and component. Visit the component
 overview page and select appropriate choice from the :guilabel:`Watching` menu.

weblate/accounts/data.py

@@ -34,7 +34,7 @@
     (
         NotificationScope.SCOPE_WATCHED,
         NotificationFrequency.FREQ_WEEKLY,
-        "NewStringNotificaton",
+        "TranslationActivitySummaryNotification",
     ),
     (
         NotificationScope.SCOPE_ADMIN,

weblate/accounts/notifications.py

@@ -8,6 +8,7 @@
 from copy import copy
 from email.utils import formataddr
 from typing import TYPE_CHECKING, Any, ClassVar, cast
+from urllib.parse import urlencode
 from uuid import uuid4
 
 from dateutil.relativedelta import relativedelta
@@ -46,6 +47,7 @@
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
+    from datetime import datetime
 
     from django.db.models import QuerySet
     from django_stubs_ext import StrOrPromise
@@ -637,6 +639,202 @@ class NewStringNotificaton(Notification):
     required_attr = "unit"
 
 
+@register_notification
+class TranslationActivitySummaryNotification(Notification):
+    verbose_plural = verbose = pgettext_lazy(
+        "Notification name", "Translation activity summary"
+    )
+    filter_languages = True
+
+    activity_fields: ClassVar[tuple[str, ...]] = (
+        "added",
+        "updated",
+        "translated",
+        "approved",
+        "needs_editing",
+    )
+    activity_actions: ClassVar[dict[str, tuple[ActionEvents, ...]]] = {
+        "added": (
+            ActionEvents.NEW_UNIT,
+            ActionEvents.NEW_UNIT_REPO,
+            ActionEvents.NEW_UNIT_UPLOAD,
+        ),
+        "updated": (
+            ActionEvents.SOURCE_CHANGE,
+            ActionEvents.STRING_REPO_UPDATE,
+            ActionEvents.STRING_UPLOAD_UPDATE,
+        ),
+        "translated": (
+            ActionEvents.CHANGE,
+            ActionEvents.NEW,
+            ActionEvents.ACCEPT,
+        ),
+        "approved": (ActionEvents.APPROVE,),
+        "needs_editing": (ActionEvents.MARKED_EDIT,),
+    }
+    digest_template = "translation_activity_summary"
+    since: datetime | None = None
+
+    @classmethod
+    def get_freq_choices(cls) -> list[tuple[int, StrOrPromise]]:
+        return [
+            x
+            for x in super().get_freq_choices()
+            if x[0] != NotificationFrequency.FREQ_INSTANT
+        ]
+
+    @classmethod
+    def get_activity_actions(cls) -> tuple[ActionEvents, ...]:
+        return tuple(
+            action for actions in cls.activity_actions.values() for action in actions
+        )
+
+    @classmethod
+    def get_activity_field(cls, action: int) -> str | None:
+        for field, actions in cls.activity_actions.items():
+            if action in actions:
+                return field
+        return None
+
+    @staticmethod
+    def get_action_query(action: ActionEvents) -> str:
+        with override("en"):
+            action_name = str(action.label).lower().replace(" ", "-")
+        return f"change_action:{action_name}"
+
+    def get_activity_query(self, actions: tuple[ActionEvents, ...]) -> str:
+        if self.since is None:
+            msg = "Activity summary period is not set"
+            raise ValueError(msg)
+        action_query = " OR ".join(self.get_action_query(action) for action in actions)
+        if len(actions) > 1:
+            action_query = f"({action_query})"
+        return f"change_time:>={self.since.isoformat()} AND {action_query}"
+
+    @staticmethod
+    def get_search_url(translation: Translation, query: str) -> str:
+        return f"{translation.get_translate_url()}?{urlencode({'q': query})}"
+
+    def notify_daily(self) -> None:
+        self.notify_activity_summary(NotificationFrequency.FREQ_DAILY, days=1)
+
+    def notify_weekly(self) -> None:
+        self.notify_activity_summary(NotificationFrequency.FREQ_WEEKLY, weeks=1)
+
+    def notify_monthly(self) -> None:
+        self.notify_activity_summary(NotificationFrequency.FREQ_MONTHLY, months=1)
+
+    def notify_activity_summary(
+        self,
+        frequency: NotificationFrequency,
+        *,
+        days: int = 0,
+        weeks: int = 0,
+        months: int = 0,
+    ) -> None:
+        self.since = timezone.now() - relativedelta(
+            days=days, weeks=weeks, months=months
+        )
+        changes = Change.objects.filter(
+            action__in=self.get_activity_actions(),
+            timestamp__gte=self.since,
+        ).prefetch_for_render()
+
+        users = {}
+        notifications: dict[int, dict[int, dict[str, Any]]] = defaultdict(dict)
+        for change in changes:
+            change.fill_in_prefetched()
+            field = self.get_activity_field(change.action)
+            if field is None or change.translation is None:
+                continue
+            for user in self.get_users(frequency, change):
+                if change.project is not None and not user.can_access_project(
+                    change.project
+                ):
+                    continue
+                users[user.pk] = user
+                user_notifications = notifications[user.pk]
+                summary = user_notifications.setdefault(
+                    change.translation.pk,
+                    {
+                        "translation": change.translation,
+                        **{
+                            activity_field: set()
+                            for activity_field in self.activity_fields
+                        },
+                    },
+                )
+                summary[field].add(change.unit_id or change.pk)
+
+        translation_ids = {
+            translation_id
+            for user_notifications in notifications.values()
+            for translation_id in user_notifications
+        }
+        translations = {
+            translation.pk: translation
+            for translation in prefetch_stats(
+                Translation.objects.filter(pk__in=translation_ids).prefetch()
+            )
+        }
+
+        for userid, user_notifications in notifications.items():
+            summaries = self.get_summary_rows(user_notifications, translations)
+            if not summaries:
+                continue
+            user = users[userid]
+            self.send_digest(
+                user.profile.language,
+                user.email,
+                summaries=summaries,
+                subscription=user.current_subscription,
+            )
+
+    def get_summary_rows(
+        self,
+        summaries: dict[int, dict[str, Any]],
+        translations: dict[int, Translation],
+    ) -> list[dict[str, Any]]:
+        result = []
+        for translation_id, summary in summaries.items():
+            translation = translations.get(translation_id, summary["translation"])
+            total = 0
+            row = {"translation": translation}
+            for field in self.activity_fields:
+                count = len(summary[field])
+                total += count
+                row[field] = {
+                    "count": count,
+                    "url": self.get_search_url(
+                        translation,
+                        self.get_activity_query(self.activity_actions[field]),
+                    ),
+                }
+            row["unfinished"] = {
+                "count": translation.stats.todo,
+                "url": self.get_search_url(translation, "state:<translated"),
+            }
+            row["total"] = total
+            result.append(row)
+        return sorted(result, key=lambda item: str(item["translation"]))
+
+    def get_context(
+        self,
+        change: Change | None = None,
+        subscription: Subscription | None = None,
+        extracontext: dict | None = None,
+        *,
+        changes: QuerySet[Change] | list[Change] | list[dict[str, Any]] | None = None,
+        summaries: list[dict[str, Any]] | None = None,
+    ) -> dict[str, Any]:
+        context = super().get_context(
+            change, subscription, extracontext, changes=changes, summaries=summaries
+        )
+        if summaries:
+            context["total_count"] = sum(item["total"] for item in summaries)
+        return context
+
+
 @register_notification
 class NewContributorNotificaton(Notification):
     actions = (ActionEvents.NEW_CONTRIBUTOR,)

weblate/accounts/tests/test_notifications.py

@@ -14,12 +14,14 @@
 from django.test import SimpleTestCase
 from django.test.utils import override_settings
 
+from weblate.accounts.data import DEFAULT_NOTIFICATIONS
 from weblate.accounts.models import AuditLog, Profile, Subscription
 from weblate.accounts.notifications import (
     RECIPIENT_USERNAME_HEADER,
     MergeFailureNotification,
     NotificationFrequency,
     NotificationScope,
+    TranslationActivitySummaryNotification,
     get_email_headers,
     get_notification_emails,
 )
@@ -114,6 +116,32 @@ def test_raw_notification_has_no_recipient_username(self) -> None:
 
         self.assertNotIn(RECIPIENT_USERNAME_HEADER, messages[0]["headers"])
 
+    def test_activity_summary_digest_only(self) -> None:
+        choices = {
+            frequency
+            for frequency, _label in TranslationActivitySummaryNotification.get_freq_choices()
+        }
+
+        self.assertNotIn(NotificationFrequency.FREQ_INSTANT, choices)
+
+    def test_activity_summary_default_notification(self) -> None:
+        self.assertIn(
+            (
+                NotificationScope.SCOPE_WATCHED,
+                NotificationFrequency.FREQ_WEEKLY,
+                "TranslationActivitySummaryNotification",
+            ),
+            DEFAULT_NOTIFICATIONS,
+        )
+        self.assertNotIn(
+            (
+                NotificationScope.SCOPE_WATCHED,
+                NotificationFrequency.FREQ_WEEKLY,
+                "NewStringNotificaton",
+            ),
+            DEFAULT_NOTIFICATIONS,
+        )
+
 
 @override_settings(
     TEMPLATES=TEMPLATES_RAISE,
@@ -162,6 +190,9 @@ def setUp(self) -> None:
                 notification=notification,
                 frequency=NotificationFrequency.FREQ_INSTANT,
             )
+        Subscription.objects.filter(
+            user=self.user, notification="TranslationActivitySummaryNotification"
+        ).delete()
         self.thirduser = User.objects.create_user(
             "thirduser", "noreply+third@example.org", "testpassword"
         )
@@ -590,6 +621,36 @@ def test_digest_new_lang(self) -> None:
             subj="New language was added or requested",
         )
 
+    def test_translation_activity_summary(self) -> None:
+        self.user.subscription_set.all().delete()
+        self.user.subscription_set.create(
+            scope=NotificationScope.SCOPE_WATCHED,
+            notification="TranslationActivitySummaryNotification",
+            frequency=NotificationFrequency.FREQ_WEEKLY,
+        )
+        unit = self.get_unit()
+        unit.change_set.create(action=ActionEvents.NEW_UNIT)
+        unit.change_set.create(action=ActionEvents.SOURCE_CHANGE)
+        unit.change_set.create(user=self.anotheruser, action=ActionEvents.CHANGE)
+        unit.change_set.create(user=self.anotheruser, action=ActionEvents.APPROVE)
+        unit.change_set.create(user=self.anotheruser, action=ActionEvents.MARKED_EDIT)
+
+        self.assertEqual(len(mail.outbox), 0)
+
+        notify_weekly()
+
+        self.validate_notifications(1, "[Weblate] Translation activity summary")
+        content = mail.outbox[0].alternatives[0][0]
+        self.assertIn("Translation activity in this period", content)
+        self.assertIn("Test/Test — Czech", content)
+        self.assertIn("change_action%3Astring-added", content)
+        self.assertIn("change_action%3Asource-string-changed", content)
+        self.assertIn("change_action%3Atranslation-changed", content)
+        self.assertIn("change_action%3Atranslation-approved", content)
+        self.assertIn("change_action%3Amarked-for-edit", content)
+        self.assertIn("state%3A%3Ctranslated", content)
+        self.assertNotIn("Hello, world", content)
+
     def test_reminder(
         self,
         frequency=NotificationFrequency.FREQ_DAILY,