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,10 @@ 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, needs editing, 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/migrations/0029_alter_subscription_notification.py

@@ -0,0 +1,66 @@
+# Copyright © Michal Čihař <michal@weblate.org>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+# Generated by Django 6.0.5 on 2026-05-12 13:58
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("accounts", "0028_alter_profile_codesite_alter_profile_fediverse_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="subscription",
+            name="notification",
+            field=models.CharField(
+                choices=[
+                    (
+                        "RepositoryNotification",
+                        "Operation was performed in the repository",
+                    ),
+                    ("LockNotification", "Component was locked or unlocked"),
+                    ("LicenseNotification", "License was changed"),
+                    ("ParseErrorNotification", "Parse error occurred"),
+                    ("NewStringNotificaton", "String is available for translation"),
+                    (
+                        "TranslationActivitySummaryNotification",
+                        "Translation activity summary",
+                    ),
+                    (
+                        "NewContributorNotificaton",
+                        "Contributor made their first translation",
+                    ),
+                    ("NewSuggestionNotificaton", "Suggestion was added"),
+                    ("LanguageTranslatedNotificaton", "Language was translated"),
+                    ("ComponentTranslatedNotificaton", "Component was translated"),
+                    ("NewCommentNotificaton", "Comment was added"),
+                    ("MentionCommentNotificaton", "You were mentioned in a comment"),
+                    (
+                        "LastAuthorCommentNotificaton",
+                        "Your translation received a comment",
+                    ),
+                    ("TranslatedStringNotificaton", "String was edited by user"),
+                    ("ApprovedStringNotificaton", "String was approved"),
+                    ("ChangedStringNotificaton", "String was changed"),
+                    (
+                        "NewTranslationNotificaton",
+                        "New language was added or requested",
+                    ),
+                    (
+                        "NewComponentNotificaton",
+                        "New translation component was created",
+                    ),
+                    ("NewAnnouncementNotificaton", "Announcement was published"),
+                    ("NewAlertNotificaton", "New alert emerged in a component"),
+                    ("MergeFailureNotification", "Repository operation failed"),
+                    ("PendingSuggestionsNotification", "Pending suggestions exist"),
+                    ("ToDoStringsNotification", "Unfinished strings exist"),
+                ],
+                max_length=100,
+            ),
+        ),
+    ]

weblate/accounts/notifications.py

@@ -8,13 +8,15 @@
 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
 from django.conf import settings
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.signing import TimestampSigner
-from django.db.models import IntegerChoices, Q
+from django.db.models import Count, IntegerChoices, Q
+from django.db.models.functions import Coalesce
 from django.template.loader import render_to_string
 from django.urls import reverse
 from django.utils import timezone
@@ -46,6 +48,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 +640,271 @@ 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 get_activity_change_filter(self, frequency: NotificationFrequency) -> Q:
+        from weblate.accounts.models import Subscription  # noqa: PLC0415
+
+        subscriptions = Subscription.objects.filter(
+            notification=self.get_name(),
+            frequency=frequency,
+            user__is_active=True,
+            user__is_bot=False,
+        )
+        if not subscriptions.exists():
+            return Q(pk__in=())
+
+        if subscriptions.filter(
+            scope__in=(NotificationScope.SCOPE_ALL, NotificationScope.SCOPE_ADMIN)
+        ).exists():
+            return Q()
+
+        project_ids = set(
+            subscriptions.filter(
+                scope=NotificationScope.SCOPE_PROJECT, project__isnull=False
+            ).values_list("project_id", flat=True)
+        )
+        project_ids.update(
+            subscriptions.filter(
+                scope=NotificationScope.SCOPE_WATCHED,
+                user__profile__watched__isnull=False,
+            ).values_list("user__profile__watched", flat=True)
+        )
+        component_ids = set(
+            subscriptions.filter(
+                scope=NotificationScope.SCOPE_COMPONENT, component__isnull=False
+            ).values_list("component_id", flat=True)
+        )
+
+        query = Q()
+        if project_ids:
+            query |= Q(project_id__in=project_ids)
+        if component_ids:
+            query |= Q(component_id__in=component_ids)
+        return query or Q(pk__in=())
+
+    def get_activity_change_rows(self, frequency: NotificationFrequency):
+        return (
+            Change.objects.filter(
+                self.get_activity_change_filter(frequency),
+                action__in=self.get_activity_actions(),
+                timestamp__gte=self.since,
+                translation__isnull=False,
+            )
+            .annotate(summary_unit_id=Coalesce("unit_id", "id"))
+            .values("translation_id", "action", "user_id")
+            .annotate(count=Count("summary_unit_id", distinct=True))
+        )
+
+    def get_activity_summary_users(
+        self,
+        frequency: NotificationFrequency,
+        translation: Translation,
+        actor_user_id: int | None,
+    ) -> Iterable[User]:
+        component = translation.component
+        project = component.project
+        last_user = None
+        for subscription in self.get_subscriptions(
+            None, project, component, translation, None
+        ):
+            user = subscription.user
+            if user == last_user or (
+                actor_user_id is not None and user.pk == actor_user_id
+            ):
+                continue
+
+            last_user = user
+            if subscription.frequency != frequency:
+                continue
+            if not user.can_access_project(project):
+                continue
+
+            user.current_subscription = subscription
+            yield user
+
+    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
+        )
+        activity_rows = list(self.get_activity_change_rows(frequency))
+        translation_ids = {row["translation_id"] for row in activity_rows}
+        translations = {
+            translation.pk: translation
+            for translation in prefetch_stats(
+                Translation.objects.filter(pk__in=translation_ids).prefetch()
+            )
+        }
+
+        users = {}
+        notifications: dict[int, dict[int, dict[str, Any]]] = defaultdict(dict)
+        for row in activity_rows:
+            field = self.get_activity_field(row["action"])
+            translation = translations.get(row["translation_id"])
+            if field is None or translation is None:
+                continue
+
+            for user in self.get_activity_summary_users(
+                frequency, translation, row["user_id"]
+            ):
+                users[user.pk] = user
+                user_notifications = notifications[user.pk]
+                summary = user_notifications.setdefault(
+                    translation.pk,
+                    {
+                        "translation": translation,
+                        **dict.fromkeys(self.activity_fields, 0),
+                    },
+                )
+                summary[field] += row["count"]
+
+        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 = 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,)