feat: уведомления администраторам о запросах подключения сайта

core/notifications.py

@@ -0,0 +1,98 @@
+"""Общая лента, сохраняющая совместимость прежнего API уведомлений экспертов."""
+
+import re
+
+from django.http import Http404
+from django.shortcuts import get_object_or_404
+from django.utils import timezone
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from partner_programs.services.registration_notifications import (
+    visible_request_notifications,
+)
+from project_rates.notifications import (
+    visible_notifications as visible_expert_notifications,
+)
+
+
+def unread_count(user):
+    return (
+        visible_expert_notifications(user).filter(read_at__isnull=True).count()
+        + visible_request_notifications(user).filter(read_at__isnull=True).count()
+    )
+
+
+class NotificationsView(APIView):
+    permission_classes = [IsAuthenticated]
+
+    def finalize_response(self, request, response, *args, **kwargs):
+        response = super().finalize_response(request, response, *args, **kwargs)
+        response["Cache-Control"] = "private, no-store"
+        return response
+
+    def get(self, request, notification_id=None):
+        if notification_id is not None:
+            return Response(status=405)
+        experts = visible_expert_notifications(request.user)
+        connections = visible_request_notifications(request.user)
+        results = [
+            {
+                "id": f"expert_joined:{row.pk}",
+                "kind": "expert_joined",
+                "text": (
+                    f"Эксперт {row.expert_name} ({row.expert_email}) вошел на платформу "
+                    f"и принял приглашение в программу «{row.invitation.partner_program.name}»."
+                ),
+                "program_id": row.invitation.partner_program_id,
+                "created_at": row.created_at,
+                "read_at": row.read_at,
+            }
+            for row in experts[:100]
+        ]
+        results.extend(
+            {
+                "id": f"registration_connection:{row.pk}",
+                "kind": "registration_connection",
+                "text": (
+                    f"Запрос на подключение сайта для программы "
+                    f"«{row.request.registration.program.name}». Автор: {row.request.requester_name}."
+                ),
+                "program_id": row.request.registration.program_id,
+                "registration_id": row.request.registration_id,
+                "created_at": row.request.created_at,
+                "read_at": row.read_at,
+            }
+            for row in connections[:100]
+        )
+        results.sort(key=lambda item: (item["created_at"], item["id"]), reverse=True)
+        return Response(
+            {"unread_count": unread_count(request.user), "results": results[:100]}
+        )
+
+    def post(self, request, notification_id=None):
+        if notification_id is None:
+            return Response(status=405)
+        match = re.fullmatch(
+            r"(expert_joined|registration_connection):([1-9][0-9]{0,18})", notification_id
+        )
+        if not match or int(match[2]) > 2**63 - 1:
+            raise Http404
+        kind, pk = match[1], int(match[2])
+        rows = (
+            visible_expert_notifications(request.user)
+            if kind == "expert_joined"
+            else visible_request_notifications(request.user)
+        )
+        notice = get_object_or_404(rows, pk=pk)
+        if notice.read_at is None:
+            rows.filter(pk=pk, read_at__isnull=True).update(read_at=timezone.now())
+            notice.refresh_from_db(fields=["read_at"])
+        return Response(
+            {
+                "id": notification_id,
+                "read_at": notice.read_at,
+                "unread_count": unread_count(request.user),
+            }
+        )

core/urls.py

@@ -4,10 +4,13 @@
     SkillsNestedView,
     SkillsInlineView,
 )
+from core.notifications import NotificationsView
 
 app_name = "core"
 
 urlpatterns = [
+    path("notifications/", NotificationsView.as_view()),
+    path("notifications/<str:notification_id>/read/", NotificationsView.as_view()),
     path("skills/nested/", SkillsNestedView.as_view()),
     path("skills/inline/", SkillsInlineView.as_view()),
 ]

partner_programs/migrations/0027_registration_request_notifications.py

@@ -0,0 +1,126 @@
+# Generated by Django 4.2.11 on 2026-10-20 12:19
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import django.utils.timezone
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("partner_programs", "0026_interface_copy"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="RegistrationConnectionRequest",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("revision", models.PositiveIntegerField()),
+                ("requester_name", models.CharField(max_length=800)),
+                ("requester_email", models.EmailField(max_length=254)),
+                ("website_url", models.URLField()),
+                ("comment", models.TextField(blank=True)),
+                ("contact", models.CharField(blank=True, max_length=500)),
+                (
+                    "created_at",
+                    models.DateTimeField(
+                        default=django.utils.timezone.now, editable=False
+                    ),
+                ),
+                (
+                    "registration",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="connection_requests",
+                        to="partner_programs.programregistration",
+                    ),
+                ),
+                (
+                    "requested_by",
+                    models.ForeignKey(
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="registration_connection_requests",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="RegistrationConnectionNotification",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("read_at", models.DateTimeField(blank=True, null=True)),
+                ("emailed_at", models.DateTimeField(blank=True, null=True)),
+                (
+                    "delivery_status",
+                    models.CharField(
+                        choices=[
+                            ("queued", "queued"),
+                            ("sent", "sent"),
+                            ("failed", "failed"),
+                            ("cancelled", "cancelled"),
+                        ],
+                        default="queued",
+                        max_length=12,
+                    ),
+                ),
+                ("attempts", models.PositiveSmallIntegerField(default=0)),
+                (
+                    "recipient",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="registration_connection_notifications",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+                (
+                    "request",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="notifications",
+                        to="partner_programs.registrationconnectionrequest",
+                    ),
+                ),
+            ],
+        ),
+        migrations.AddConstraint(
+            model_name="registrationconnectionrequest",
+            constraint=models.UniqueConstraint(
+                fields=("registration", "revision"),
+                name="unique_connection_request_revision",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="registrationconnectionnotification",
+            index=models.Index(
+                fields=["delivery_status", "id"], name="partner_pro_deliver_9389f1_idx"
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="registrationconnectionnotification",
+            constraint=models.UniqueConstraint(
+                fields=("request", "recipient"),
+                name="unique_connection_request_recipient",
+            ),
+        ),
+    ]

partner_programs/models.py

@@ -9,6 +9,8 @@
 from partner_programs.registration_models import (  # noqa: F401
     ProgramRegistration,
     PendingProgramRegistration,
+    RegistrationConnectionRequest,
+    RegistrationConnectionNotification,
 )
 
 User = get_user_model()

partner_programs/registration_models.py

@@ -5,6 +5,7 @@
 from django.conf import settings
 from django.core.exceptions import ValidationError
 from django.db import models
+from django.utils import timezone
 
 
 class ProgramRegistration(models.Model):
@@ -26,9 +27,7 @@ class ProgramRegistration(models.Model):
     external_url = models.URLField(blank=True)
     connection_website_url = models.URLField("Сайт мероприятия", blank=True)
     connection_comment = models.TextField(blank=True)
-    connection_contact = models.CharField(
-        "Контакт для связи", max_length=500, blank=True
-    )
+    connection_contact = models.CharField("Контакт для связи", max_length=500, blank=True)
     requested_by = models.ForeignKey(
         settings.AUTH_USER_MODEL, null=True, blank=True, on_delete=models.SET_NULL
     )
@@ -63,3 +62,62 @@ class Meta:
                 fields=["program", "user"], name="unique_pending_program_registration"
             )
         ]
+
+
+class RegistrationConnectionRequest(models.Model):
+    """Снимок запроса; изменения анкеты не переписывают отправленные детали."""
+
+    registration = models.ForeignKey(
+        ProgramRegistration, on_delete=models.CASCADE, related_name="connection_requests"
+    )
+    revision = models.PositiveIntegerField()
+    requested_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        null=True,
+        on_delete=models.SET_NULL,
+        related_name="registration_connection_requests",
+    )
+    requester_name = models.CharField(max_length=800)
+    requester_email = models.EmailField()
+    website_url = models.URLField()
+    comment = models.TextField(blank=True)
+    contact = models.CharField(max_length=500, blank=True)
+    created_at = models.DateTimeField(default=timezone.now, editable=False)
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=["registration", "revision"],
+                name="unique_connection_request_revision",
+            )
+        ]
+
+
+class RegistrationConnectionNotification(models.Model):
+    request = models.ForeignKey(
+        RegistrationConnectionRequest,
+        on_delete=models.CASCADE,
+        related_name="notifications",
+    )
+    recipient = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="registration_connection_notifications",
+    )
+    read_at = models.DateTimeField(null=True, blank=True)
+    emailed_at = models.DateTimeField(null=True, blank=True)
+    delivery_status = models.CharField(
+        max_length=12,
+        default="queued",
+        choices=[(value, value) for value in ("queued", "sent", "failed", "cancelled")],
+    )
+    attempts = models.PositiveSmallIntegerField(default=0)
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=["request", "recipient"],
+                name="unique_connection_request_recipient",
+            )
+        ]
+        indexes = [models.Index(fields=["delivery_status", "id"])]

partner_programs/registration_views.py

@@ -138,6 +138,15 @@ def post(self, request, pk):
         program = managed_program(pk, request.user, lock=True)
         config = service.locked_config(program)
         if config.external_status != "connected":
+            duplicate = (
+                config.external_status == "requested"
+                and config.connection_website_url == data["url"]
+                and config.connection_comment == data["comment"]
+                and config.connection_contact == data["contact"]
+                and config.connection_requests.exists()
+            )
+            if duplicate:
+                return Response(service.settings_data(program))
             config.connection_website_url = data["url"]
             config.connection_comment = data["comment"]
             config.connection_contact = data["contact"]
@@ -146,6 +155,9 @@ def post(self, request, pk):
             config.external_status = "requested"
             config.revision += 1
             config.save()
+            from partner_programs.services.registration_notifications import record_request
+
+            record_request(config, request.user)
         return Response(service.settings_data(program))