arthexis 0.1.23__py3-none-any.whl → 0.1.25__py3-none-any.whl

ocpp/tests.py

@@ -67,6 +67,7 @@ from .models import (
     MeterReading,
     Location,
     DataTransferMessage,
+    CPReservation,
 )
 from .admin import ChargerConfigurationAdmin
 from .consumers import CSMSConsumer
@@ -304,6 +305,184 @@ class ChargerRefreshManagerNodeTests(TestCase):
         self.assertEqual(charger.manager_node, remote)
 
 
+class CPReservationTests(TransactionTestCase):
+    def setUp(self):
+        self.location = Location.objects.create(name="Reservation Site")
+        self.aggregate = Charger.objects.create(charger_id="RSV100", location=self.location)
+        self.connector_one = Charger.objects.create(
+            charger_id="RSV100", connector_id=1, location=self.location
+        )
+        self.connector_two = Charger.objects.create(
+            charger_id="RSV100", connector_id=2, location=self.location
+        )
+        self.addCleanup(store.clear_pending_calls, "RSV100")
+
+    def test_allocates_preferred_connector(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation(
+            location=self.location,
+            start_time=start,
+            duration_minutes=90,
+            id_tag="TAG001",
+        )
+        reservation.save()
+        self.assertEqual(reservation.connector, self.connector_two)
+
+    def test_allocation_falls_back_and_blocks_overlaps(self):
+        start = timezone.now() + timedelta(hours=1)
+        first = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=60,
+            id_tag="TAG002",
+        )
+        self.assertEqual(first.connector, self.connector_two)
+        second = CPReservation(
+            location=self.location,
+            start_time=start + timedelta(minutes=15),
+            duration_minutes=60,
+            id_tag="TAG003",
+        )
+        second.save()
+        self.assertEqual(second.connector, self.connector_one)
+        third = CPReservation(
+            location=self.location,
+            start_time=start + timedelta(minutes=30),
+            duration_minutes=45,
+            id_tag="TAG004",
+        )
+        with self.assertRaises(ValidationError):
+            third.save()
+
+    def test_send_reservation_request_dispatches_frame(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=30,
+            id_tag="TAG005",
+        )
+
+        class DummyConnection:
+            def __init__(self):
+                self.sent: list[str] = []
+
+            async def send(self, message):
+                self.sent.append(message)
+
+        ws = DummyConnection()
+        store.set_connection(
+            reservation.connector.charger_id,
+            reservation.connector.connector_id,
+            ws,
+        )
+        self.addCleanup(
+            store.pop_connection,
+            reservation.connector.charger_id,
+            reservation.connector.connector_id,
+        )
+
+        message_id = reservation.send_reservation_request()
+        self.assertTrue(ws.sent)
+        frame = json.loads(ws.sent[0])
+        self.assertEqual(frame[0], 2)
+        self.assertEqual(frame[2], "ReserveNow")
+        self.assertEqual(frame[3]["reservationId"], reservation.pk)
+        self.assertEqual(frame[3]["connectorId"], reservation.connector.connector_id)
+        self.assertEqual(frame[3]["idTag"], "TAG005")
+        metadata = store.pending_calls.get(message_id)
+        self.assertIsNotNone(metadata)
+        self.assertEqual(metadata.get("reservation_pk"), reservation.pk)
+
+    def test_call_result_marks_reservation_confirmed(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=45,
+            id_tag="TAG006",
+        )
+        log_key = store.identity_key(
+            reservation.connector.charger_id, reservation.connector.connector_id
+        )
+        message_id = "reserve-success"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ReserveNow",
+                "charger_id": reservation.connector.charger_id,
+                "connector_id": reservation.connector.connector_id,
+                "log_key": log_key,
+                "reservation_pk": reservation.pk,
+            },
+        )
+
+        consumer = CSMSConsumer()
+        consumer.scope = {"headers": [], "client": ("127.0.0.1", 1234)}
+        consumer.charger_id = reservation.connector.charger_id
+        consumer.store_key = log_key
+        consumer.connector_value = reservation.connector.connector_id
+        consumer.charger = reservation.connector
+        consumer.aggregate_charger = self.aggregate
+        consumer._consumption_task = None
+        consumer._consumption_message_uuid = None
+        consumer.send = AsyncMock()
+
+        async_to_sync(consumer._handle_call_result)(
+            message_id, {"status": "Accepted"}
+        )
+        reservation.refresh_from_db()
+        self.assertTrue(reservation.evcs_confirmed)
+        self.assertEqual(reservation.evcs_status, "Accepted")
+        self.assertIsNotNone(reservation.evcs_confirmed_at)
+
+    def test_call_error_updates_reservation_status(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=45,
+            id_tag="TAG007",
+        )
+        log_key = store.identity_key(
+            reservation.connector.charger_id, reservation.connector.connector_id
+        )
+        message_id = "reserve-error"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ReserveNow",
+                "charger_id": reservation.connector.charger_id,
+                "connector_id": reservation.connector.connector_id,
+                "log_key": log_key,
+                "reservation_pk": reservation.pk,
+            },
+        )
+
+        consumer = CSMSConsumer()
+        consumer.scope = {"headers": [], "client": ("127.0.0.1", 1234)}
+        consumer.charger_id = reservation.connector.charger_id
+        consumer.store_key = log_key
+        consumer.connector_value = reservation.connector.connector_id
+        consumer.charger = reservation.connector
+        consumer.aggregate_charger = self.aggregate
+        consumer._consumption_task = None
+        consumer._consumption_message_uuid = None
+        consumer.send = AsyncMock()
+
+        async_to_sync(consumer._handle_call_error)(
+            message_id,
+            "Rejected",
+            "Charger unavailable",
+            {"reason": "maintenance"},
+        )
+        reservation.refresh_from_db()
+        self.assertFalse(reservation.evcs_confirmed)
+        self.assertEqual(reservation.evcs_status, "")
+        self.assertIsNone(reservation.evcs_confirmed_at)
+        self.assertIn("Rejected", reservation.evcs_error or "")
+
+
 class ChargerUrlFallbackTests(TestCase):
     @override_settings(ALLOWED_HOSTS=["fallback.example", "10.0.0.0/8"])
     def test_reference_created_when_site_missing(self):

ocpp/views.py

@@ -47,6 +47,7 @@ CALL_ACTION_LABELS = {
     "DataTransfer": _("Data transfer"),
     "Reset": _("Reset"),
     "TriggerMessage": _("Trigger message"),
+    "ReserveNow": _("Reserve connector"),
 }
 
 CALL_EXPECTED_STATUSES: dict[str, set[str]] = {
@@ -56,6 +57,7 @@ CALL_EXPECTED_STATUSES: dict[str, set[str]] = {
     "DataTransfer": {"Accepted"},
     "Reset": {"Accepted"},
     "TriggerMessage": {"Accepted"},
+    "ReserveNow": {"Accepted"},
 }
 
 

pages/middleware.py

@@ -10,7 +10,7 @@ from django.conf import settings
 from django.urls import Resolver404, resolve
 
 from .models import Landing, LandingLead, ViewHistory
-from .utils import landing_leads_supported
+from .utils import cache_original_referer, get_original_referer, landing_leads_supported
 
 
 logger = logging.getLogger(__name__)
@@ -30,6 +30,7 @@ class ViewHistoryMiddleware:
         )
 
     def __call__(self, request):
+        cache_original_referer(request)
         should_track = self._should_track(request)
         if not should_track:
             return self.get_response(request)
@@ -132,7 +133,7 @@ class ViewHistoryMiddleware:
         if not landing_leads_supported():
             return
 
-        referer = request.META.get("HTTP_REFERER", "") or ""
+        referer = get_original_referer(request)
         user_agent = request.META.get("HTTP_USER_AGENT", "") or ""
         ip_address = self._extract_client_ip(request) or None
         user = getattr(request, "user", None)

pages/tests.py

@@ -515,6 +515,23 @@ class InvitationTests(TestCase):
         self.assertEqual(lead.mac_address, "")
         self.assertEqual(len(mail.outbox), 0)
 
+    def test_request_invite_uses_original_referer(self):
+        InviteLead.objects.all().delete()
+        self.client.get(
+            reverse("pages:index"),
+            HTTP_REFERER="https://campaign.example/landing",
+        )
+
+        resp = self.client.post(
+            reverse("pages:request-invite"),
+            {"email": "origin@example.com"},
+            HTTP_REFERER="http://testserver/pages/request-invite/",
+        )
+
+        self.assertEqual(resp.status_code, 200)
+        lead = InviteLead.objects.get()
+        self.assertEqual(lead.referer, "https://campaign.example/landing")
+
     def test_request_invite_falls_back_to_send_mail(self):
         node = Node.objects.create(
             hostname="local", address="127.0.0.1", mac_address="00:11:22:33:44:55"
@@ -3531,6 +3548,28 @@ class UserStorySubmissionTests(TestCase):
         story = UserStory.objects.get()
         self.assertEqual(story.language_code, "es")
 
+    def test_submission_prefers_original_referer(self):
+        self.client.get(
+            reverse("pages:index"),
+            HTTP_REFERER="https://ads.example/original",
+        )
+        response = self.client.post(
+            self.url,
+            {
+                "rating": 3,
+                "comments": "Works well",
+                "path": "/wizard/step-2/",
+                "name": "visitor@example.com",
+                "take_screenshot": "0",
+            },
+            HTTP_REFERER="http://testserver/wizard/step-2/",
+            HTTP_USER_AGENT="FeedbackBot/2.0",
+        )
+
+        self.assertEqual(response.status_code, 200)
+        story = UserStory.objects.get()
+        self.assertEqual(story.referer, "https://ads.example/original")
+
     def test_superuser_submission_creates_triage_todo(self):
         Todo.objects.all().delete()
         superuser = get_user_model().objects.create_superuser(
@@ -3591,6 +3630,7 @@ class UserStorySubmissionTests(TestCase):
             screenshot_file,
             method="USER_STORY",
             user=self.user,
+            link_duplicates=True,
         )
 
     def test_anonymous_submission_uses_provided_email(self):

pages/utils.py

@@ -1,6 +1,15 @@
+from __future__ import annotations
+
+from urllib.parse import urlsplit
+
+from django.core.exceptions import DisallowedHost
+from django.http.request import split_domain_port
 from django.urls import path as django_path
 
 
+ORIGINAL_REFERER_SESSION_KEY = "pages:original_referer"
+
+
 def landing(label=None):
     """Decorator to mark a view as a landing page."""
 
@@ -12,6 +21,67 @@ def landing(label=None):
     return decorator
 
 
+def cache_original_referer(request) -> None:
+    """Persist the first external referer observed for the session."""
+
+    session = getattr(request, "session", None)
+    if not hasattr(session, "get"):
+        return
+
+    original = session.get(ORIGINAL_REFERER_SESSION_KEY)
+    if original:
+        request.original_referer = original
+        return
+
+    referer = (request.META.get("HTTP_REFERER") or "").strip()
+    if not referer:
+        return
+
+    try:
+        parsed = urlsplit(referer)
+    except ValueError:
+        return
+
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        return
+
+    try:
+        host = request.get_host()
+    except DisallowedHost:
+        host = ""
+
+    referer_host, _ = split_domain_port(parsed.netloc)
+    request_host, _ = split_domain_port(host)
+
+    if referer_host and request_host:
+        if referer_host.lower() == request_host.lower():
+            return
+
+    referer_value = referer[:1000]
+    session[ORIGINAL_REFERER_SESSION_KEY] = referer_value
+    request.original_referer = referer_value
+
+
+def get_original_referer(request) -> str:
+    """Return the original external referer recorded for the session."""
+
+    if hasattr(request, "original_referer"):
+        return request.original_referer or ""
+
+    session = getattr(request, "session", None)
+    if hasattr(session, "get"):
+        referer = session.get(ORIGINAL_REFERER_SESSION_KEY)
+        if referer:
+            request.original_referer = referer
+            return referer
+
+    referer = (request.META.get("HTTP_REFERER") or "").strip()
+    if referer:
+        referer = referer[:1000]
+    request.original_referer = referer
+    return referer
+
+
 def landing_leads_supported() -> bool:
     """Return ``True`` when the local node supports landing lead tracking."""
 

pages/views.py

@@ -66,6 +66,8 @@ from core.models import (
     SecurityGroup,
     Todo,
 )
+from ocpp.models import Charger
+from .utils import get_original_referer
 
 try:  # pragma: no cover - optional dependency guard
     from graphviz import Digraph
@@ -1113,7 +1115,7 @@ def request_invite(request):
                 comment=comment,
                 user=request.user if request.user.is_authenticated else None,
                 path=request.path,
-                referer=request.META.get("HTTP_REFERER", ""),
+                referer=get_original_referer(request),
                 user_agent=request.META.get("HTTP_USER_AGENT", ""),
                 ip_address=ip_address,
                 mac_address=mac_address or "",
@@ -1269,6 +1271,25 @@ class ClientReportForm(forms.Form):
         input_formats=["%Y-%m"],
         help_text=_("Generates the report for the calendar month that you select."),
     )
+    language = forms.ChoiceField(
+        label=_("Report language"),
+        choices=settings.LANGUAGES,
+        help_text=_("Choose the language used for the generated report."),
+    )
+    title = forms.CharField(
+        label=_("Report title"),
+        required=False,
+        max_length=200,
+        help_text=_("Optional heading that replaces the default report title."),
+    )
+    chargers = forms.ModelMultipleChoiceField(
+        label=_("Charge points"),
+        queryset=Charger.objects.filter(connector_id__isnull=True)
+        .order_by("display_name", "charger_id"),
+        required=False,
+        widget=forms.CheckboxSelectMultiple,
+        help_text=_("Choose which charge points are included in the report."),
+    )
     owner = forms.ModelChoiceField(
         queryset=get_user_model().objects.all(),
         required=False,
@@ -1299,6 +1320,13 @@ class ClientReportForm(forms.Form):
         super().__init__(*args, **kwargs)
         if request and getattr(request, "user", None) and request.user.is_authenticated:
             self.fields["owner"].initial = request.user.pk
+        self.fields["chargers"].widget.attrs["class"] = "charger-options"
+        language_initial = ClientReport.default_language()
+        if request:
+            language_initial = ClientReport.normalize_language(
+                getattr(request, "LANGUAGE_CODE", language_initial)
+            )
+        self.fields["language"].initial = language_initial
 
     def clean(self):
         cleaned = super().clean()
@@ -1348,6 +1376,10 @@ class ClientReportForm(forms.Form):
             emails.append(candidate)
         return emails
 
+    def clean_title(self):
+        title = self.cleaned_data.get("title")
+        return ClientReport.normalize_title(title)
+
 
 @live_update()
 def client_report(request):
@@ -1358,7 +1390,7 @@ def client_report(request):
         if not request.user.is_authenticated:
             form.is_valid()  # Run validation to surface field errors alongside auth error.
             form.add_error(
-                None, _("You must log in to generate client reports."),
+                None, _("You must log in to generate consumer reports."),
             )
         elif form.is_valid():
             throttle_seconds = getattr(settings, "CLIENT_REPORT_THROTTLE_SECONDS", 60)
@@ -1387,7 +1419,7 @@ def client_report(request):
                 form.add_error(
                     None,
                     _(
-                        "Client reports can only be generated periodically. Please wait before trying again."
+                        "Consumer reports can only be generated periodically. Please wait before trying again."
                     ),
                 )
             else:
@@ -1399,14 +1431,36 @@ def client_report(request):
                 recipients = (
                     form.cleaned_data.get("destinations") if enable_emails else []
                 )
+                chargers = list(form.cleaned_data.get("chargers") or [])
+                language = form.cleaned_data.get("language")
+                title = form.cleaned_data.get("title")
                 report = ClientReport.generate(
                     form.cleaned_data["start"],
                     form.cleaned_data["end"],
                     owner=owner,
                     recipients=recipients,
                     disable_emails=disable_emails,
+                    chargers=chargers,
+                    language=language,
+                    title=title,
                 )
                 report.store_local_copy()
+                if chargers:
+                    report.chargers.set(chargers)
+                if enable_emails and recipients:
+                    delivered = report.send_delivery(
+                        to=recipients,
+                        cc=[],
+                        outbox=ClientReport.resolve_outbox_for_owner(owner),
+                        reply_to=ClientReport.resolve_reply_to_for_owner(owner),
+                    )
+                    if delivered:
+                        report.recipients = delivered
+                        report.save(update_fields=["recipients"])
+                        messages.success(
+                            request,
+                            _("Consumer report emailed to the selected recipients."),
+                        )
                 recurrence = form.cleaned_data.get("recurrence")
                 if recurrence and recurrence != ClientReportSchedule.PERIODICITY_NONE:
                     schedule = ClientReportSchedule.objects.create(
@@ -1415,13 +1469,17 @@ def client_report(request):
                         periodicity=recurrence,
                         email_recipients=recipients,
                         disable_emails=disable_emails,
+                        language=language,
+                        title=title,
                     )
+                    if chargers:
+                        schedule.chargers.set(chargers)
                     report.schedule = schedule
                     report.save(update_fields=["schedule"])
                     messages.success(
                         request,
                         _(
-                            "Client report schedule created; future reports will be generated automatically."
+                            "Consumer report schedule created; future reports will be generated automatically."
                         ),
                     )
                 if disable_emails:
@@ -1459,7 +1517,6 @@ def client_report(request):
         "schedule": schedule,
         "login_url": login_url,
         "download_url": download_url,
-        "previous_reports": _client_report_history(request),
     }
     return render(request, "pages/client_report.html", context)
 
@@ -1478,32 +1535,6 @@ def client_report_download(request, report_id: int):
     response = FileResponse(pdf_path.open("rb"), content_type="application/pdf")
     response["Content-Disposition"] = f'attachment; filename="{filename}"'
     return response
-
-
-def _client_report_history(request, limit: int = 20):
-    if not request.user.is_authenticated:
-        return []
-    qs = ClientReport.objects.order_by("-created_on")
-    if not request.user.is_staff:
-        qs = qs.filter(owner=request.user)
-    history = []
-    for report in qs[:limit]:
-        totals = report.rows_for_display.get("totals", {})
-        history.append(
-            {
-                "instance": report,
-                "download_url": reverse("pages:client-report-download", args=[report.pk]),
-                "email_enabled": not report.disable_emails,
-                "recipients": report.recipients or [],
-                "totals": {
-                    "total_kw": totals.get("total_kw", 0.0),
-                    "total_kw_period": totals.get("total_kw_period", 0.0),
-                },
-            }
-        )
-    return history
-
-
 def _get_request_language_code(request) -> str:
     language_code = ""
     if hasattr(request, "session"):
@@ -1562,7 +1593,7 @@ def submit_user_story(request):
         if not story.name:
             story.name = str(_("Anonymous"))[:40]
         story.path = (story.path or request.get_full_path())[:500]
-        story.referer = request.META.get("HTTP_REFERER", "")
+        story.referer = get_original_referer(request)
         story.user_agent = request.META.get("HTTP_USER_AGENT", "")
         story.ip_address = client_ip or None
         story.is_user_data = True
@@ -1634,6 +1665,7 @@ def submit_user_story(request):
                         screenshot_path,
                         method="USER_STORY",
                         user=story.user if story.user_id else None,
+                        link_duplicates=True,
                     )
                 except Exception:  # pragma: no cover - best effort persistence
                     logger.exception(