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

core/models.py

@@ -8,7 +8,7 @@ from django.db.models import Q
 from django.db.models.functions import Lower, Length
 from django.conf import settings
 from django.contrib.auth import get_user_model
-from django.utils.translation import gettext_lazy as _
+from django.utils.translation import gettext_lazy as _, gettext, override
 from django.core.validators import MaxValueValidator, MinValueValidator, RegexValidator
 from django.core.exceptions import ValidationError
 from django.apps import apps
@@ -33,7 +33,7 @@ import re
 from io import BytesIO
 from django.core.files.base import ContentFile
 import qrcode
-from django.utils import timezone
+from django.utils import timezone, formats
 from django.utils.dateparse import parse_datetime
 import uuid
 from pathlib import Path
@@ -51,6 +51,51 @@ xmlrpc_client = defused_xmlrpc.xmlrpc_client
 
 logger = logging.getLogger(__name__)
 
+
+def _available_language_codes() -> set[str]:
+    return {code.lower() for code, _ in getattr(settings, "LANGUAGES", [])}
+
+
+def default_report_language() -> str:
+    configured = getattr(settings, "LANGUAGE_CODE", "en") or "en"
+    configured = configured.replace("_", "-").lower()
+    base = configured.split("-", 1)[0]
+    available = _available_language_codes()
+    if base in available:
+        return base
+    if configured in available:
+        return configured
+    if available:
+        return next(iter(sorted(available)))
+    return "en"
+
+
+def normalize_report_language(language: str | None) -> str:
+    default = default_report_language()
+    if not language:
+        return default
+    candidate = str(language).strip().lower()
+    if not candidate:
+        return default
+    candidate = candidate.replace("_", "-")
+    available = _available_language_codes()
+    if candidate in available:
+        return candidate
+    base = candidate.split("-", 1)[0]
+    if base in available:
+        return base
+    return default
+
+
+def normalize_report_title(title: str | None) -> str:
+    value = (title or "").strip()
+    if "\r" in value or "\n" in value:
+        raise ValidationError(
+            _("Report title cannot contain control characters."),
+        )
+    return value
+
+
 from .entity import Entity, EntityUserManager, EntityManager
 from .release import (
     Package as ReleasePackage,
@@ -589,11 +634,21 @@ class OdooProfile(Profile):
         """Return the display label for this profile."""
 
         username = self._resolved_field_value("username")
+        database = self._resolved_field_value("database")
+        if username and database:
+            return f"{username}@{database}"
         if username:
             return username
-        database = self._resolved_field_value("database")
         return database or ""
 
+    def _profile_name(self) -> str:
+        """Return the stored name for this profile without database suffix."""
+
+        username = self._resolved_field_value("username")
+        if username:
+            return username
+        return self._resolved_field_value("database")
+
     def save(self, *args, **kwargs):
         if self.pk:
             old = type(self).all_objects.get(pk=self.pk)
@@ -604,7 +659,7 @@ class OdooProfile(Profile):
                 or old.host != self.host
             ):
                 self._clear_verification()
-        computed_name = self._display_identifier()
+        computed_name = self._profile_name()
         update_fields = kwargs.get("update_fields")
         update_fields_set = set(update_fields) if update_fields is not None else None
         if computed_name != self.name:
@@ -639,6 +694,7 @@ class OdooProfile(Profile):
         self.odoo_uid = uid
         self.email = info.get("email", "")
         self.verified_on = timezone.now()
+        self.name = self._profile_name()
         self.save(update_fields=["odoo_uid", "name", "email", "verified_on"])
         return True
 
@@ -2722,8 +2778,24 @@ class ClientReportSchedule(Entity):
     periodicity = models.CharField(
         max_length=12, choices=PERIODICITY_CHOICES, default=PERIODICITY_NONE
     )
+    language = models.CharField(
+        max_length=12,
+        choices=settings.LANGUAGES,
+        default=default_report_language,
+    )
+    title = models.CharField(
+        max_length=200,
+        blank=True,
+        default="",
+        verbose_name=_("Title"),
+    )
     email_recipients = models.JSONField(default=list, blank=True)
     disable_emails = models.BooleanField(default=False)
+    chargers = models.ManyToManyField(
+        "ocpp.Charger",
+        blank=True,
+        related_name="client_report_schedules",
+    )
     periodic_task = models.OneToOneField(
         "django_celery_beat.PeriodicTask",
         on_delete=models.SET_NULL,
@@ -2737,11 +2809,19 @@ class ClientReportSchedule(Entity):
         verbose_name = "Client Report Schedule"
         verbose_name_plural = "Client Report Schedules"
 
+    @classmethod
+    def label_for_periodicity(cls, value: str) -> str:
+        lookup = dict(cls.PERIODICITY_CHOICES)
+        return lookup.get(value, value)
+
     def __str__(self) -> str:  # pragma: no cover - simple representation
         owner = self.owner.get_username() if self.owner else "Unassigned"
         return f"Client Report Schedule ({owner})"
 
     def save(self, *args, **kwargs):
+        if self.language:
+            self.language = normalize_report_language(self.language)
+        self.title = normalize_report_title(self.title)
         sync = kwargs.pop("sync_task", True)
         super().save(*args, **kwargs)
         if sync and self.pk:
@@ -2833,6 +2913,78 @@ class ClientReportSchedule(Entity):
 
         return start, end
 
+    def _advance_period(
+        self, start: datetime_date, end: datetime_date
+    ) -> tuple[datetime_date, datetime_date]:
+        import calendar as _calendar
+        import datetime as _datetime
+
+        if self.periodicity == self.PERIODICITY_DAILY:
+            delta = _datetime.timedelta(days=1)
+            return start + delta, end + delta
+        if self.periodicity == self.PERIODICITY_WEEKLY:
+            delta = _datetime.timedelta(days=7)
+            return start + delta, end + delta
+        if self.periodicity == self.PERIODICITY_MONTHLY:
+            base_start = start.replace(day=1)
+            year = base_start.year
+            month = base_start.month
+            if month == 12:
+                next_year = year + 1
+                next_month = 1
+            else:
+                next_year = year
+                next_month = month + 1
+            next_start = base_start.replace(year=next_year, month=next_month, day=1)
+            last_day = _calendar.monthrange(next_year, next_month)[1]
+            next_end = next_start.replace(day=last_day)
+            return next_start, next_end
+        raise ValueError("advance_period called for non-recurring schedule")
+
+    def iter_pending_periods(self, reference=None):
+        from django.utils import timezone
+
+        if self.periodicity == self.PERIODICITY_NONE:
+            return []
+
+        ref_date = reference or timezone.localdate()
+        try:
+            target_start, target_end = self.calculate_period(reference=ref_date)
+        except ValueError:
+            return []
+
+        reports = self.reports.order_by("start_date", "end_date")
+        last_report = reports.last()
+        if last_report:
+            current_start, current_end = self._advance_period(
+                last_report.start_date, last_report.end_date
+            )
+        else:
+            current_start, current_end = target_start, target_end
+
+        if current_end < current_start:
+            return []
+
+        pending: list[tuple[datetime.date, datetime.date]] = []
+        safety = 0
+        while current_end <= target_end:
+            exists = reports.filter(
+                start_date=current_start, end_date=current_end
+            ).exists()
+            if not exists:
+                pending.append((current_start, current_end))
+            try:
+                current_start, current_end = self._advance_period(
+                    current_start, current_end
+                )
+            except ValueError:
+                break
+            safety += 1
+            if safety > 400:
+                break
+
+        return pending
+
     def resolve_recipients(self):
         """Return (to, cc) email lists respecting owner fallbacks."""
 
@@ -2880,38 +3032,27 @@ class ClientReportSchedule(Entity):
 
         return to, cc
 
+    def resolve_reply_to(self) -> list[str]:
+        return ClientReport.resolve_reply_to_for_owner(self.owner)
+
     def get_outbox(self):
         """Return the preferred :class:`nodes.models.EmailOutbox` instance."""
 
-        from nodes.models import EmailOutbox, Node
-
-        if self.owner:
-            try:
-                outbox = self.owner.get_profile(EmailOutbox)
-            except Exception:  # pragma: no cover - defensive catch
-                outbox = None
-            if outbox:
-                return outbox
-
-        node = Node.get_local()
-        if node:
-            return getattr(node, "email_outbox", None)
-        return None
+        return ClientReport.resolve_outbox_for_owner(self.owner)
 
     def notify_failure(self, message: str):
         from nodes.models import NetMessage
 
         NetMessage.broadcast("Client report delivery issue", message)
 
-    def run(self):
+    def run(self, *, start: datetime_date | None = None, end: datetime_date | None = None):
         """Generate the report, persist it and deliver notifications."""
 
-        from core import mailer
-
-        try:
-            start, end = self.calculate_period()
-        except ValueError:
-            return None
+        if start is None or end is None:
+            try:
+                start, end = self.calculate_period()
+            except ValueError:
+                return None
 
         try:
             report = ClientReport.generate(
@@ -2921,8 +3062,12 @@ class ClientReportSchedule(Entity):
                 schedule=self,
                 recipients=self.email_recipients,
                 disable_emails=self.disable_emails,
+                chargers=list(self.chargers.all()),
+                language=self.language,
+                title=self.title,
             )
-            export, html_content = report.store_local_copy()
+            report.chargers.set(self.chargers.all())
+            report.store_local_copy()
         except Exception as exc:
             self.notify_failure(str(exc))
             raise
@@ -2934,43 +3079,12 @@ class ClientReportSchedule(Entity):
                 raise RuntimeError("No recipients available for client report")
             else:
                 try:
-                    attachments = []
-                    html_name = Path(export["html_path"]).name
-                    attachments.append((html_name, html_content, "text/html"))
-                    json_file = Path(settings.BASE_DIR) / export["json_path"]
-                    if json_file.exists():
-                        attachments.append(
-                            (
-                                json_file.name,
-                                json_file.read_text(encoding="utf-8"),
-                                "application/json",
-                            )
-                        )
-                    pdf_path = export.get("pdf_path")
-                    if pdf_path:
-                        pdf_file = Path(settings.BASE_DIR) / pdf_path
-                        if pdf_file.exists():
-                            attachments.append(
-                                (
-                                    pdf_file.name,
-                                    pdf_file.read_bytes(),
-                                    "application/pdf",
-                                )
-                            )
-                    subject = f"Client report {report.start_date} to {report.end_date}"
-                    body = (
-                        "Attached is the client report generated for the period "
-                        f"{report.start_date} to {report.end_date}."
-                    )
-                    mailer.send(
-                        subject,
-                        body,
-                        to,
-                        outbox=self.get_outbox(),
+                    delivered = report.send_delivery(
+                        to=to,
                         cc=cc,
-                        attachments=attachments,
+                        outbox=self.get_outbox(),
+                        reply_to=self.resolve_reply_to(),
                     )
-                    delivered = list(dict.fromkeys(to + (cc or [])))
                     if delivered:
                         type(report).objects.filter(pk=report.pk).update(
                             recipients=delivered
@@ -2985,6 +3099,14 @@ class ClientReportSchedule(Entity):
         self.last_generated_on = now
         return report
 
+    def generate_missing_reports(self, reference=None):
+        generated: list["ClientReport"] = []
+        for start, end in self.iter_pending_periods(reference=reference):
+            report = self.run(start=start, end=end)
+            if report:
+                generated.append(report)
+        return generated
+
 
 class ClientReport(Entity):
     """Snapshot of energy usage over a period."""
@@ -3007,15 +3129,70 @@ class ClientReport(Entity):
         blank=True,
         related_name="reports",
     )
+    language = models.CharField(
+        max_length=12,
+        choices=settings.LANGUAGES,
+        default=default_report_language,
+    )
+    title = models.CharField(
+        max_length=200,
+        blank=True,
+        default="",
+        verbose_name=_("Title"),
+    )
     recipients = models.JSONField(default=list, blank=True)
     disable_emails = models.BooleanField(default=False)
+    chargers = models.ManyToManyField(
+        "ocpp.Charger",
+        blank=True,
+        related_name="client_reports",
+    )
 
     class Meta:
-        verbose_name = "Consumer Report"
-        verbose_name_plural = "Consumer Reports"
+        verbose_name = _("Consumer Report")
+        verbose_name_plural = _("Consumer Reports")
         db_table = "core_client_report"
         ordering = ["-created_on"]
 
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        period_type = (
+            self.schedule.periodicity
+            if self.schedule
+            else ClientReportSchedule.PERIODICITY_NONE
+        )
+        return f"{self.start_date} - {self.end_date} ({period_type})"
+
+    @staticmethod
+    def default_language() -> str:
+        return default_report_language()
+
+    @staticmethod
+    def normalize_language(language: str | None) -> str:
+        return normalize_report_language(language)
+
+    @staticmethod
+    def normalize_title(title: str | None) -> str:
+        return normalize_report_title(title)
+
+    def save(self, *args, **kwargs):
+        if self.language:
+            self.language = normalize_report_language(self.language)
+        self.title = self.normalize_title(self.title)
+        super().save(*args, **kwargs)
+
+    @property
+    def periodicity_label(self) -> str:
+        if self.schedule:
+            return self.schedule.get_periodicity_display()
+        return ClientReportSchedule.label_for_periodicity(
+            ClientReportSchedule.PERIODICITY_NONE
+        )
+
+    @property
+    def total_kw_period(self) -> float:
+        totals = (self.rows_for_display or {}).get("totals", {})
+        return float(totals.get("total_kw_period", 0.0) or 0.0)
+
     @classmethod
     def generate(
         cls,
@@ -3026,9 +3203,23 @@ class ClientReport(Entity):
         schedule=None,
         recipients: list[str] | None = None,
         disable_emails: bool = False,
+        chargers=None,
+        language: str | None = None,
+        title: str | None = None,
     ):
-        payload = cls.build_rows(start_date, end_date)
-        return cls.objects.create(
+        from collections.abc import Iterable as _Iterable
+
+        charger_list = []
+        if chargers:
+            if isinstance(chargers, _Iterable):
+                charger_list = list(chargers)
+            else:
+                charger_list = [chargers]
+
+        payload = cls.build_rows(start_date, end_date, chargers=charger_list)
+        normalized_language = cls.normalize_language(language)
+        title_value = cls.normalize_title(title)
+        report = cls.objects.create(
             start_date=start_date,
             end_date=end_date,
             data=payload,
@@ -3036,7 +3227,12 @@ class ClientReport(Entity):
             schedule=schedule,
             recipients=list(recipients or []),
             disable_emails=disable_emails,
+            language=normalized_language,
+            title=title_value,
         )
+        if charger_list:
+            report.chargers.set(charger_list)
+        return report
 
     def store_local_copy(self, html: str | None = None):
         """Persist the report data and optional HTML rendering to disk."""
@@ -3050,9 +3246,16 @@ class ClientReport(Entity):
         timestamp = timezone.now().strftime("%Y%m%d%H%M%S")
         identifier = f"client_report_{self.pk}_{timestamp}"
 
-        html_content = html or render_to_string(
-            "core/reports/client_report_email.html", {"report": self}
-        )
+        language_code = self.normalize_language(self.language)
+        context = {
+            "report": self,
+            "language_code": language_code,
+            "default_language": type(self).default_language(),
+        }
+        with override(language_code):
+            html_content = html or render_to_string(
+                "core/reports/client_report_email.html", context
+            )
         html_path = report_dir / f"{identifier}.html"
         html_path.write_text(html_content, encoding="utf-8")
 
@@ -3076,15 +3279,86 @@ class ClientReport(Entity):
         self.data = updated
         return export, html_content
 
+    def send_delivery(
+        self,
+        *,
+        to: list[str] | tuple[str, ...],
+        cc: list[str] | tuple[str, ...] | None = None,
+        outbox=None,
+        reply_to: list[str] | None = None,
+    ) -> list[str]:
+        from core import mailer
+
+        recipients = list(to or [])
+        if not recipients:
+            return []
+
+        pdf_path = self.ensure_pdf()
+        attachments = [
+            (pdf_path.name, pdf_path.read_bytes(), "application/pdf"),
+        ]
+
+        language_code = self.normalize_language(self.language)
+        with override(language_code):
+            totals = self.rows_for_display.get("totals", {})
+            start_display = formats.date_format(
+                self.start_date, format="DATE_FORMAT", use_l10n=True
+            )
+            end_display = formats.date_format(
+                self.end_date, format="DATE_FORMAT", use_l10n=True
+            )
+            total_kw_period_label = gettext("Total kW during period")
+            total_kw_all_label = gettext("Total kW (all time)")
+            report_title = self.normalize_title(self.title) or gettext(
+                "Consumer Report"
+            )
+            body_lines = [
+                gettext("%(title)s for %(start)s through %(end)s.")
+                % {"title": report_title, "start": start_display, "end": end_display},
+                f"{total_kw_period_label}: "
+                f"{formats.number_format(totals.get('total_kw_period', 0.0), decimal_pos=2, use_l10n=True)}.",
+                f"{total_kw_all_label}: "
+                f"{formats.number_format(totals.get('total_kw', 0.0), decimal_pos=2, use_l10n=True)}.",
+            ]
+            message = "\n".join(body_lines)
+            subject = gettext("%(title)s %(start)s - %(end)s") % {
+                "title": report_title,
+                "start": start_display,
+                "end": end_display,
+            }
+
+        kwargs = {}
+        if reply_to:
+            kwargs["reply_to"] = reply_to
+
+        mailer.send(
+            subject,
+            message,
+            recipients,
+            outbox=outbox,
+            cc=list(cc or []),
+            attachments=attachments,
+            **kwargs,
+        )
+
+        delivered = list(dict.fromkeys(recipients + list(cc or [])))
+        return delivered
+
     @staticmethod
-    def build_rows(start_date=None, end_date=None, *, for_display: bool = False):
-        dataset = ClientReport._build_dataset(start_date, end_date)
+    def build_rows(
+        start_date=None,
+        end_date=None,
+        *,
+        for_display: bool = False,
+        chargers=None,
+    ):
+        dataset = ClientReport._build_dataset(start_date, end_date, chargers=chargers)
         if for_display:
             return ClientReport._normalize_dataset_for_display(dataset)
         return dataset
 
     @staticmethod
-    def _build_dataset(start_date=None, end_date=None):
+    def _build_dataset(start_date=None, end_date=None, *, chargers=None):
         from datetime import datetime, time, timedelta, timezone as pytimezone
         from ocpp.models import Charger, Transaction
 
@@ -3101,6 +3375,14 @@ class ClientReport(Entity):
             )
             qs = qs.filter(start_time__lt=end_dt)
 
+        selected_base_ids = None
+        if chargers:
+            selected_base_ids = {
+                charger.charger_id for charger in chargers if charger.charger_id
+            }
+            if selected_base_ids:
+                qs = qs.filter(charger__charger_id__in=selected_base_ids)
+
         qs = qs.select_related("account", "charger").prefetch_related("meter_values")
         transactions = list(qs.order_by("start_time", "pk"))
 
@@ -3134,6 +3416,8 @@ class ClientReport(Entity):
             if charger is None:
                 continue
             base_id = charger.charger_id
+            if selected_base_ids is not None and base_id not in selected_base_ids:
+                continue
             aggregator = aggregator_map.get(base_id) or charger
             entry = groups.setdefault(
                 base_id,
@@ -3224,6 +3508,10 @@ class ClientReport(Entity):
                 }
             )
 
+        filters: dict[str, Any] = {}
+        if selected_base_ids:
+            filters["chargers"] = sorted(selected_base_ids)
+
         return {
             "schema": "evcs-session/v1",
             "evcs": evcs_entries,
@@ -3231,6 +3519,7 @@ class ClientReport(Entity):
                 "total_kw": total_all_time,
                 "total_kw_period": total_period,
             },
+            "filters": filters,
         }
 
     @staticmethod
@@ -3263,6 +3552,31 @@ class ClientReport(Entity):
 
         return start_value, end_value
 
+    @staticmethod
+    def _format_session_datetime(value):
+        if not value:
+            return None
+        localized = timezone.localtime(value)
+        date_part = formats.date_format(
+            localized, format="MONTH_DAY_FORMAT", use_l10n=True
+        )
+        time_part = formats.time_format(
+            localized, format="TIME_FORMAT", use_l10n=True
+        )
+        return gettext("%(date)s, %(time)s") % {
+            "date": date_part,
+            "time": time_part,
+        }
+
+    @staticmethod
+    def _calculate_duration_minutes(start, end):
+        if not start or not end:
+            return None
+        total_seconds = (end - start).total_seconds()
+        if total_seconds < 0:
+            return None
+        return int(round(total_seconds / 60.0))
+
     @staticmethod
     def _normalize_dataset_for_display(dataset: dict[str, Any]):
         schema = dataset.get("schema")
@@ -3298,6 +3612,15 @@ class ClientReport(Entity):
                             "session_kwh": row.get("session_kwh"),
                             "start": start_dt,
                             "end": end_dt,
+                            "start_display": ClientReport._format_session_datetime(
+                                start_dt
+                            ),
+                            "end_display": ClientReport._format_session_datetime(
+                                end_dt
+                            ),
+                            "duration_minutes": ClientReport._calculate_duration_minutes(
+                                start_dt, end_dt
+                            ),
                         }
                     )
 
@@ -3330,6 +3653,7 @@ class ClientReport(Entity):
                     "total_kw": totals.get("total_kw", 0.0),
                     "total_kw_period": totals.get("total_kw_period", 0.0),
                 },
+                "filters": dataset.get("filters", {}),
             }
 
         if schema == "session-list/v1":
@@ -3345,6 +3669,7 @@ class ClientReport(Entity):
                         start_dt = timezone.make_aware(start_dt, timezone.utc)
                     item["start"] = start_dt
                 else:
+                    start_dt = None
                     item["start"] = None
 
                 if end_val:
@@ -3353,13 +3678,24 @@ class ClientReport(Entity):
                         end_dt = timezone.make_aware(end_dt, timezone.utc)
                     item["end"] = end_dt
                 else:
+                    end_dt = None
                     item["end"] = None
 
+                item["start_display"] = ClientReport._format_session_datetime(start_dt)
+                item["end_display"] = ClientReport._format_session_datetime(end_dt)
+                item["duration_minutes"] = ClientReport._calculate_duration_minutes(
+                    start_dt, end_dt
+                )
+
                 parsed.append(item)
 
             return {"schema": schema, "rows": parsed}
 
-        return {"schema": schema, "rows": dataset.get("rows", [])}
+        return {
+            "schema": schema,
+            "rows": dataset.get("rows", []),
+            "filters": dataset.get("filters", {}),
+        }
 
     @property
     def rows_for_display(self):
@@ -3373,6 +3709,37 @@ class ClientReport(Entity):
         except ValueError:
             return str(path)
 
+    @staticmethod
+    def resolve_reply_to_for_owner(owner) -> list[str]:
+        if not owner:
+            return []
+        try:
+            inbox = owner.get_profile(EmailInbox)
+        except Exception:  # pragma: no cover - defensive catch
+            inbox = None
+        if inbox and getattr(inbox, "username", ""):
+            address = inbox.username.strip()
+            if address:
+                return [address]
+        return []
+
+    @staticmethod
+    def resolve_outbox_for_owner(owner):
+        from nodes.models import EmailOutbox, Node
+
+        if owner:
+            try:
+                outbox = owner.get_profile(EmailOutbox)
+            except Exception:  # pragma: no cover - defensive catch
+                outbox = None
+            if outbox:
+                return outbox
+
+        node = Node.get_local()
+        if node:
+            return getattr(node, "email_outbox", None)
+        return None
+
     def render_pdf(self, target: Path):
         from reportlab.lib import colors
         from reportlab.lib.pagesizes import landscape, letter
@@ -3392,157 +3759,195 @@ class ClientReport(Entity):
         dataset = self.rows_for_display
         schema = dataset.get("schema")
 
-        styles = getSampleStyleSheet()
-        title_style = styles["Title"]
-        subtitle_style = styles["Heading2"]
-        normal_style = styles["BodyText"]
-        emphasis_style = styles["Heading3"]
-
-        document = SimpleDocTemplate(
-            str(target_path),
-            pagesize=landscape(letter),
-            leftMargin=0.5 * inch,
-            rightMargin=0.5 * inch,
-            topMargin=0.6 * inch,
-            bottomMargin=0.5 * inch,
-        )
-
-        story: list = []
-        story.append(Paragraph("Consumer Report", title_style))
-        story.append(
-            Paragraph(
-                f"Period: {self.start_date} to {self.end_date}",
-                emphasis_style,
+        language_code = self.normalize_language(self.language)
+        with override(language_code):
+            styles = getSampleStyleSheet()
+            title_style = styles["Title"]
+            subtitle_style = styles["Heading2"]
+            normal_style = styles["BodyText"]
+            emphasis_style = styles["Heading3"]
+
+            document = SimpleDocTemplate(
+                str(target_path),
+                pagesize=landscape(letter),
+                leftMargin=0.5 * inch,
+                rightMargin=0.5 * inch,
+                topMargin=0.6 * inch,
+                bottomMargin=0.5 * inch,
             )
-        )
-        story.append(Spacer(1, 0.25 * inch))
 
-        if schema == "evcs-session/v1":
-            evcs_entries = dataset.get("evcs", [])
-            if not evcs_entries:
-                story.append(
-                    Paragraph(
-                        "No charging sessions recorded for the selected period.",
-                        normal_style,
-                    )
-                )
-            for index, evcs in enumerate(evcs_entries):
-                if index:
-                    story.append(Spacer(1, 0.2 * inch))
-
-                display_name = evcs.get("display_name") or "Charge Point"
-                serial_number = evcs.get("serial_number")
-                header_text = display_name
-                if serial_number:
-                    header_text = f"{display_name} (Serial: {serial_number})"
-                story.append(Paragraph(header_text, subtitle_style))
-
-                metrics_text = (
-                    f"Total kW (all time): {evcs.get('total_kw', 0.0):.2f} | "
-                    f"Total kW (period): {evcs.get('total_kw_period', 0.0):.2f}"
-                )
-                story.append(Paragraph(metrics_text, normal_style))
-                story.append(Spacer(1, 0.1 * inch))
-
-                transactions = evcs.get("transactions", [])
-                if transactions:
-                    table_data = [
-                        [
-                            "Connector",
-                            "Start kWh",
-                            "End kWh",
-                            "Session kWh",
-                            "Start Time",
-                            "End Time",
-                            "RFID Label",
-                            "Account",
-                        ]
-                    ]
+            story: list = []
 
-                    def _format_number(value):
-                        return f"{value:.2f}" if value is not None else "—"
+            report_title = self.normalize_title(self.title) or gettext(
+                "Consumer Report"
+            )
+            story.append(Paragraph(report_title, title_style))
 
-                    for row in transactions:
-                        start_dt = row.get("start")
-                        end_dt = row.get("end")
-                        start_display = (
-                            timezone.localtime(start_dt).strftime("%Y-%m-%d %H:%M")
-                            if start_dt
-                            else "—"
-                        )
-                        end_display = (
-                            timezone.localtime(end_dt).strftime("%Y-%m-%d %H:%M")
-                            if end_dt
-                            else "—"
-                        )
+            start_display = formats.date_format(
+                self.start_date, format="DATE_FORMAT", use_l10n=True
+            )
+            end_display = formats.date_format(
+                self.end_date, format="DATE_FORMAT", use_l10n=True
+            )
+            story.append(
+                Paragraph(
+                    gettext("Period: %(start)s to %(end)s")
+                    % {"start": start_display, "end": end_display},
+                    emphasis_style,
+                )
+            )
+            story.append(Spacer(1, 0.25 * inch))
+
+            total_kw_all_time_label = gettext("Total kW (all time)")
+            total_kw_period_label = gettext("Total kW (period)")
+            connector_label = gettext("Connector")
+            account_label = gettext("Account")
+            session_kwh_label = gettext("Session kW")
+            time_label = gettext("Time")
+            no_sessions_period = gettext(
+                "No charging sessions recorded for the selected period."
+            )
+            no_sessions_point = gettext(
+                "No charging sessions recorded for this charge point."
+            )
+            no_structured_data = gettext(
+                "No structured data is available for this report."
+            )
+            report_totals_label = gettext("Report totals")
+            total_kw_period_line = gettext("Total kW during period")
+
+            def format_datetime(value):
+                if not value:
+                    return "—"
+                return ClientReport._format_session_datetime(value) or "—"
+
+            def format_decimal(value):
+                if value is None:
+                    return "—"
+                return formats.number_format(value, decimal_pos=2, use_l10n=True)
+
+            def format_duration(value):
+                if value is None:
+                    return "—"
+                return formats.number_format(value, decimal_pos=0, use_l10n=True)
+
+            if schema == "evcs-session/v1":
+                evcs_entries = dataset.get("evcs", [])
+                if not evcs_entries:
+                    story.append(Paragraph(no_sessions_period, normal_style))
+                for index, evcs in enumerate(evcs_entries):
+                    if index:
+                        story.append(Spacer(1, 0.2 * inch))
+
+                    display_name = evcs.get("display_name") or gettext("Charge Point")
+                    serial_number = evcs.get("serial_number")
+                    if serial_number:
+                        header_text = gettext("%(name)s (Serial: %(serial)s)") % {
+                            "name": display_name,
+                            "serial": serial_number,
+                        }
+                    else:
+                        header_text = display_name
+                    story.append(Paragraph(header_text, subtitle_style))
+
+                    metrics_text = (
+                        f"{total_kw_all_time_label}: "
+                        f"{format_decimal(evcs.get('total_kw', 0.0))} | "
+                        f"{total_kw_period_label}: "
+                        f"{format_decimal(evcs.get('total_kw_period', 0.0))}"
+                    )
+                    story.append(Paragraph(metrics_text, normal_style))
+                    story.append(Spacer(1, 0.1 * inch))
 
-                        table_data.append(
+                    transactions = evcs.get("transactions", [])
+                    if transactions:
+                        table_data = [
                             [
-                                row.get("connector")
-                                if row.get("connector") is not None
-                                else "—",
-                                _format_number(row.get("start_kwh")),
-                                _format_number(row.get("end_kwh")),
-                                _format_number(row.get("session_kwh")),
-                                start_display,
-                                end_display,
-                                row.get("rfid_label") or "—",
-                                row.get("account_name") or "—",
+                                session_kwh_label,
+                                gettext("Session start"),
+                                gettext("Session end"),
+                                time_label,
+                                connector_label,
+                                gettext("RFID label"),
+                                account_label,
                             ]
-                        )
+                        ]
 
-                    table = Table(table_data, repeatRows=1)
-                    table.setStyle(
-                        TableStyle(
-                            [
-                                ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#0f172a")),
-                                ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
-                                ("ALIGN", (0, 0), (-1, 0), "CENTER"),
-                                ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"),
-                                ("FONTSIZE", (0, 0), (-1, 0), 9),
-                                (
-                                    "ROWBACKGROUNDS",
-                                    (0, 1),
-                                    (-1, -1),
-                                    [colors.whitesmoke, colors.HexColor("#eef2ff")],
-                                ),
-                                ("GRID", (0, 0), (-1, -1), 0.25, colors.grey),
-                                ("VALIGN", (0, 1), (-1, -1), "MIDDLE"),
-                            ]
+                        for row in transactions:
+                            start_dt = row.get("start")
+                            end_dt = row.get("end")
+                            duration_value = row.get("duration_minutes")
+                            table_data.append(
+                                [
+                                    format_decimal(row.get("session_kwh")),
+                                    format_datetime(start_dt),
+                                    format_datetime(end_dt),
+                                    format_duration(duration_value),
+                                    row.get("connector")
+                                    if row.get("connector") is not None
+                                    else "—",
+                                    row.get("rfid_label") or "—",
+                                    row.get("account_name") or "—",
+                                ]
+                            )
+
+                        column_count = len(table_data[0])
+                        col_width = document.width / column_count if column_count else None
+                        table = Table(
+                            table_data,
+                            repeatRows=1,
+                            colWidths=[col_width] * column_count if col_width else None,
+                            hAlign="LEFT",
                         )
-                    )
-                    story.append(table)
-                else:
-                    story.append(
-                        Paragraph(
-                            "No charging sessions recorded for this charge point.",
-                            normal_style,
+                        table.setStyle(
+                            TableStyle(
+                                [
+                                    (
+                                        "BACKGROUND",
+                                        (0, 0),
+                                        (-1, 0),
+                                        colors.HexColor("#0f172a"),
+                                    ),
+                                    ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
+                                    ("ALIGN", (0, 0), (-1, 0), "CENTER"),
+                                    ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"),
+                                    ("FONTSIZE", (0, 0), (-1, 0), 9),
+                                    (
+                                        "ROWBACKGROUNDS",
+                                        (0, 1),
+                                        (-1, -1),
+                                        [colors.whitesmoke, colors.HexColor("#eef2ff")],
+                                    ),
+                                    ("GRID", (0, 0), (-1, -1), 0.25, colors.grey),
+                                    ("VALIGN", (0, 1), (-1, -1), "MIDDLE"),
+                                ]
+                            )
                         )
-                    )
-        else:
+                        story.append(table)
+                    else:
+                        story.append(Paragraph(no_sessions_point, normal_style))
+            else:
+                story.append(Paragraph(no_structured_data, normal_style))
+
+            totals = dataset.get("totals") or {}
+            story.append(Spacer(1, 0.3 * inch))
+            story.append(Paragraph(report_totals_label, emphasis_style))
             story.append(
                 Paragraph(
-                    "No structured data is available for this report.",
-                    normal_style,
+                    f"{total_kw_all_time_label}: "
+                    f"{format_decimal(totals.get('total_kw', 0.0))}",
+                    emphasis_style,
                 )
             )
-
-        totals = dataset.get("totals") or {}
-        story.append(Spacer(1, 0.3 * inch))
-        story.append(
-            Paragraph(
-                f"Report totals — Total kW (all time): {totals.get('total_kw', 0.0):.2f}",
-                emphasis_style,
-            )
-        )
-        story.append(
-            Paragraph(
-                f"Total kW during period: {totals.get('total_kw_period', 0.0):.2f}",
-                emphasis_style,
+            story.append(
+                Paragraph(
+                    f"{total_kw_period_line}: "
+                    f"{format_decimal(totals.get('total_kw_period', 0.0))}",
+                    emphasis_style,
+                )
             )
-        )
 
-        document.build(story)
+            document.build(story)
 
     def ensure_pdf(self) -> Path:
         base_dir = Path(settings.BASE_DIR)