arthexis 0.1.26__py3-none-any.whl → 0.1.28__py3-none-any.whl

core/models.py

@@ -4,7 +4,7 @@ from django.contrib.auth.models import (
     UserManager as DjangoUserManager,
 )
 from django.db import DatabaseError, IntegrityError, connections, models, transaction
-from django.db.models import Q
+from django.db.models import Q, F
 from django.db.models.functions import Lower, Length
 from django.conf import settings
 from django.contrib.auth import get_user_model
@@ -42,6 +42,7 @@ from django.core.management.color import no_style
 from urllib.parse import quote, quote_plus, urlparse
 from zoneinfo import ZoneInfo
 from utils import revision as revision_utils
+from core.celery_utils import normalize_periodic_task_name
 from typing import Any, Type
 from defusedxml import xmlrpc as defused_xmlrpc
 import requests
@@ -388,7 +389,6 @@ class User(Entity, AbstractUser):
     objects = EntityUserManager()
     all_objects = DjangoUserManager()
     """Custom user model."""
-    birthday = models.DateField(null=True, blank=True)
     data_path = models.CharField(max_length=255, blank=True)
     last_visit_ip_address = models.GenericIPAddressField(null=True, blank=True)
     operate_as = models.ForeignKey(
@@ -579,6 +579,11 @@ class User(Entity, AbstractUser):
         return self._direct_profile("GoogleCalendarProfile")
 
 
+    class Meta(AbstractUser.Meta):
+        verbose_name = _("User")
+        verbose_name_plural = _("Users")
+
+
 class UserPhoneNumber(Entity):
     """Store phone numbers associated with a user."""
 
@@ -605,11 +610,19 @@ class UserPhoneNumber(Entity):
 class OdooProfile(Profile):
     """Store Odoo API credentials for a user."""
 
+    class CRM(models.TextChoices):
+        ODOO = "odoo", _("Odoo")
+
     profile_fields = ("host", "database", "username", "password")
     host = SigilShortAutoField(max_length=255)
     database = SigilShortAutoField(max_length=255)
     username = SigilShortAutoField(max_length=255)
     password = SigilShortAutoField(max_length=255)
+    crm = models.CharField(
+        max_length=32,
+        choices=CRM.choices,
+        default=CRM.ODOO,
+    )
     verified_on = models.DateTimeField(null=True, blank=True)
     odoo_uid = models.PositiveIntegerField(null=True, blank=True, editable=False)
     name = models.CharField(max_length=255, blank=True, editable=False)
@@ -733,8 +746,8 @@ class OdooProfile(Profile):
         return f"{owner} @ {self.host}" if owner else self.host
 
     class Meta:
-        verbose_name = _("Odoo Employee")
-        verbose_name_plural = _("Odoo Employees")
+        verbose_name = _("CRM Employee")
+        verbose_name_plural = _("CRM Employees")
         constraints = [
             models.CheckConstraint(
                 check=(
@@ -747,24 +760,47 @@ class OdooProfile(Profile):
 
 
 class OpenPayProfile(Profile):
-    """Store OpenPay gateway credentials for a user or security group."""
+    """Store payment processor credentials for a user or security group."""
+
+    PROCESSOR_OPENPAY = "openpay"
+    PROCESSOR_PAYPAL = "paypal"
+    PROCESSOR_CHOICES = (
+        (PROCESSOR_OPENPAY, _("OpenPay")),
+        (PROCESSOR_PAYPAL, _("PayPal")),
+    )
 
     SANDBOX_API_URL = "https://sandbox-api.openpay.mx/v1"
     PRODUCTION_API_URL = "https://api.openpay.mx/v1"
 
+    PAYPAL_SANDBOX_API_URL = "https://api-m.sandbox.paypal.com"
+    PAYPAL_PRODUCTION_API_URL = "https://api-m.paypal.com"
+
     profile_fields = (
         "merchant_id",
         "private_key",
         "public_key",
         "is_production",
         "webhook_secret",
+        "paypal_client_id",
+        "paypal_client_secret",
+        "paypal_webhook_id",
+        "paypal_is_production",
     )
 
-    merchant_id = SigilShortAutoField(max_length=100)
-    private_key = SigilShortAutoField(max_length=255)
-    public_key = SigilShortAutoField(max_length=255)
+    default_processor = models.CharField(
+        max_length=20,
+        choices=PROCESSOR_CHOICES,
+        default=PROCESSOR_OPENPAY,
+    )
+    merchant_id = SigilShortAutoField(max_length=100, blank=True)
+    private_key = SigilShortAutoField(max_length=255, blank=True)
+    public_key = SigilShortAutoField(max_length=255, blank=True)
     is_production = models.BooleanField(default=False)
     webhook_secret = SigilShortAutoField(max_length=255, blank=True)
+    paypal_client_id = SigilShortAutoField(max_length=255, blank=True)
+    paypal_client_secret = SigilShortAutoField(max_length=255, blank=True)
+    paypal_webhook_id = SigilShortAutoField(max_length=255, blank=True)
+    paypal_is_production = models.BooleanField(default=False)
     verified_on = models.DateTimeField(null=True, blank=True)
     verification_reference = models.CharField(max_length=255, blank=True, editable=False)
 
@@ -781,6 +817,11 @@ class OpenPayProfile(Profile):
                 or old.public_key != self.public_key
                 or old.is_production != self.is_production
                 or old.webhook_secret != self.webhook_secret
+                or old.default_processor != self.default_processor
+                or old.paypal_client_id != self.paypal_client_id
+                or old.paypal_client_secret != self.paypal_client_secret
+                or old.paypal_webhook_id != self.paypal_webhook_id
+                or old.paypal_is_production != self.paypal_is_production
             ):
                 self._clear_verification()
         super().save(*args, **kwargs)
@@ -789,6 +830,8 @@ class OpenPayProfile(Profile):
     def is_verified(self):
         return self.verified_on is not None
 
+    # --- OpenPay helpers -------------------------------------------------
+
     def get_api_base_url(self) -> str:
         return self.PRODUCTION_API_URL if self.is_production else self.SANDBOX_API_URL
 
@@ -805,6 +848,47 @@ class OpenPayProfile(Profile):
     def is_sandbox(self) -> bool:
         return not self.is_production
 
+    # --- PayPal helpers --------------------------------------------------
+
+    def get_paypal_api_base_url(self) -> str:
+        return (
+            self.PAYPAL_PRODUCTION_API_URL
+            if self.paypal_is_production
+            else self.PAYPAL_SANDBOX_API_URL
+        )
+
+    def get_paypal_auth(self) -> tuple[str, str]:
+        return (self.paypal_client_id, self.paypal_client_secret)
+
+    # --- Processor utilities --------------------------------------------
+
+    def has_openpay_credentials(self) -> bool:
+        return all(
+            getattr(self, field)
+            for field in ("merchant_id", "private_key", "public_key")
+        )
+
+    def has_paypal_credentials(self) -> bool:
+        return all(
+            getattr(self, field)
+            for field in ("paypal_client_id", "paypal_client_secret")
+        )
+
+    def iter_processors(self):
+        preferred = self.default_processor or self.PROCESSOR_OPENPAY
+        ordered = [preferred]
+        other = (
+            self.PROCESSOR_PAYPAL
+            if preferred == self.PROCESSOR_OPENPAY
+            else self.PROCESSOR_OPENPAY
+        )
+        ordered.append(other)
+        for processor in ordered:
+            if processor == self.PROCESSOR_OPENPAY and self.has_openpay_credentials():
+                yield processor
+            elif processor == self.PROCESSOR_PAYPAL and self.has_paypal_credentials():
+                yield processor
+
     def sign_webhook(self, payload: bytes | str, timestamp: str | None = None) -> str:
         if not self.webhook_secret:
             raise ValueError("Webhook secret is not configured")
@@ -837,7 +921,7 @@ class OpenPayProfile(Profile):
         self._clear_verification()
         return self
 
-    def verify(self):
+    def _verify_openpay(self):
         url = self.build_api_url("charges")
         try:
             response = requests.get(
@@ -886,13 +970,62 @@ class OpenPayProfile(Profile):
         self.save(update_fields=["verification_reference", "verified_on"])
         return True
 
+    def _verify_paypal(self):
+        url = f"{self.get_paypal_api_base_url()}/v1/oauth2/token"
+        try:
+            response = requests.post(
+                url,
+                auth=self.get_paypal_auth(),
+                data={"grant_type": "client_credentials"},
+                timeout=10,
+            )
+        except requests.RequestException as exc:  # pragma: no cover - network failure
+            self._clear_verification()
+            if self.pk:
+                self.save(update_fields=["verification_reference", "verified_on"])
+            raise ValidationError(
+                _("Unable to verify PayPal credentials: %(error)s")
+                % {"error": exc}
+            ) from exc
+        if response.status_code != 200:
+            self._clear_verification()
+            if self.pk:
+                self.save(update_fields=["verification_reference", "verified_on"])
+            raise ValidationError(_("Invalid PayPal credentials"))
+        try:
+            payload = response.json() or {}
+        except ValueError:
+            payload = {}
+        scope = ""
+        if isinstance(payload, dict):
+            scope = payload.get("scope") or payload.get("access_token") or ""
+        self.verification_reference = f"PayPal: {scope}" if scope else "PayPal"
+        self.verified_on = timezone.now()
+        self.save(update_fields=["verification_reference", "verified_on"])
+        return True
+
+    def verify(self):
+        errors = []
+        for processor in self.iter_processors():
+            try:
+                if processor == self.PROCESSOR_OPENPAY:
+                    return self._verify_openpay()
+                if processor == self.PROCESSOR_PAYPAL:
+                    return self._verify_paypal()
+            except ValidationError as exc:
+                errors.append(exc)
+        if errors:
+            raise errors[-1]
+        raise ValidationError(_("No payment processors are configured."))
+
     def __str__(self):  # pragma: no cover - simple representation
         owner = self.owner_display()
-        return f"{owner} @ {self.merchant_id}" if owner else self.merchant_id
+        identifier = self.merchant_id or self.paypal_client_id or ""
+        return f"{owner} @ {identifier}" if owner and identifier else (owner or identifier)
 
     class Meta:
-        verbose_name = _("OpenPay Merchant")
-        verbose_name_plural = _("OpenPay Merchants")
+        verbose_name = _("Payment Processor")
+        verbose_name_plural = _("Payment Processors")
         constraints = [
             models.CheckConstraint(
                 check=(
@@ -1995,6 +2128,11 @@ class Reference(Entity):
         return (self.alt_text,)
 
 
+    class Meta:
+        verbose_name = _("Reference")
+        verbose_name_plural = _("References")
+
+
 class RFID(Entity):
     """RFID tag that may be assigned to one account."""
 
@@ -2871,7 +3009,8 @@ class ClientReportSchedule(Entity):
                 month_of_year="*",
             )
 
-        name = f"client_report_schedule_{self.pk}"
+        raw_name = f"client_report_schedule_{self.pk}"
+        name = normalize_periodic_task_name(PeriodicTask.objects, raw_name)
         defaults = {
             "crontab": schedule,
             "task": "core.tasks.run_client_report_schedule",
@@ -3358,7 +3497,11 @@ class ClientReport(Entity):
     @staticmethod
     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
+        from ocpp.models import (
+            Charger,
+            Transaction,
+            annotate_transaction_energy_bounds,
+        )
 
         qs = Transaction.objects.all()
 
@@ -3381,7 +3524,12 @@ class ClientReport(Entity):
             if selected_base_ids:
                 qs = qs.filter(charger__charger_id__in=selected_base_ids)
 
-        qs = qs.select_related("account", "charger").prefetch_related("meter_values")
+        qs = qs.select_related("account", "charger")
+        qs = annotate_transaction_energy_bounds(
+            qs,
+            start_field="report_meter_energy_start",
+            end_field="report_meter_energy_end",
+        )
         transactions = list(qs.order_by("start_time", "pk"))
 
         rfid_values = {tx.rfid for tx in transactions if tx.rfid}
@@ -3533,20 +3681,34 @@ class ClientReport(Entity):
         start_value = _convert(getattr(tx, "meter_start", None))
         end_value = _convert(getattr(tx, "meter_stop", None))
 
-        readings_manager = getattr(tx, "meter_values", None)
-        readings = []
-        if readings_manager is not None:
-            readings = [
-                reading
-                for reading in readings_manager.all()
-                if getattr(reading, "energy", None) is not None
-            ]
-        if readings:
-            readings.sort(key=lambda item: item.timestamp)
-            if start_value is None:
-                start_value = float(readings[0].energy or 0)
-            if end_value is None:
-                end_value = float(readings[-1].energy or 0)
+        def _coerce_energy(value):
+            if value in {None, ""}:
+                return None
+            try:
+                return float(value)
+            except (TypeError, ValueError):
+                return None
+
+        if start_value is None:
+            annotated_start = getattr(tx, "report_meter_energy_start", None)
+            start_value = _coerce_energy(annotated_start)
+
+        if end_value is None:
+            annotated_end = getattr(tx, "report_meter_energy_end", None)
+            end_value = _coerce_energy(annotated_end)
+
+        if start_value is None or end_value is None:
+            readings_manager = getattr(tx, "meter_values", None)
+            if readings_manager is not None:
+                qs = readings_manager.filter(energy__isnull=False).order_by("timestamp")
+                if start_value is None:
+                    first_energy = qs.values_list("energy", flat=True).first()
+                    start_value = _coerce_energy(first_energy)
+                if end_value is None:
+                    last_energy = qs.order_by("-timestamp").values_list(
+                        "energy", flat=True
+                    ).first()
+                    end_value = _coerce_energy(last_energy)
 
         return start_value, end_value
 
@@ -3707,6 +3869,43 @@ class ClientReport(Entity):
         except ValueError:
             return str(path)
 
+    @classmethod
+    def _load_pdf_template(cls, language_code: str | None) -> dict[str, str]:
+        from django.template import TemplateDoesNotExist
+        from django.template.loader import render_to_string
+
+        candidates: list[str] = []
+        normalized = cls.normalize_language(language_code)
+        if normalized:
+            candidates.append(normalized)
+
+        default_code = default_report_language()
+        if default_code and default_code not in candidates:
+            candidates.append(default_code)
+
+        if "en" not in candidates:
+            candidates.append("en")
+
+        for code in dict.fromkeys(candidates):
+            template_name = f"core/reports/client_report_pdf/{code}.json"
+            try:
+                rendered = render_to_string(template_name)
+            except TemplateDoesNotExist:
+                continue
+            if not rendered:
+                continue
+            try:
+                data = json.loads(rendered)
+            except json.JSONDecodeError:
+                logger.warning(
+                    "Invalid client report PDF template %s", template_name, exc_info=True
+                )
+                continue
+            if isinstance(data, dict):
+                return data
+
+        return {}
+
     @staticmethod
     def resolve_reply_to_for_owner(owner) -> list[str]:
         if not owner:
@@ -3775,9 +3974,16 @@ class ClientReport(Entity):
             )
 
             story: list = []
+            labels = self._load_pdf_template(language_code)
 
-            report_title = self.normalize_title(self.title) or gettext(
-                "Consumer Report"
+            def label(key: str, default: str) -> str:
+                value = labels.get(key) if isinstance(labels, dict) else None
+                if isinstance(value, str) and value.strip():
+                    return value
+                return gettext(default)
+
+            report_title = self.normalize_title(self.title) or label(
+                "title", "Consumer Report"
             )
             story.append(Paragraph(report_title, title_style))
 
@@ -3787,32 +3993,58 @@ class ClientReport(Entity):
             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,
-                )
-            )
+            default_period_text = gettext("Period: %(start)s to %(end)s") % {
+                "start": start_display,
+                "end": end_display,
+            }
+            period_template = labels.get("period") if isinstance(labels, dict) else None
+            if isinstance(period_template, str):
+                try:
+                    period_text = period_template.format(
+                        start=start_display, end=end_display
+                    )
+                except (KeyError, IndexError, ValueError):
+                    logger.warning(
+                        "Invalid period template for client report PDF: %s",
+                        period_template,
+                    )
+                    period_text = default_period_text
+            else:
+                period_text = default_period_text
+            story.append(Paragraph(period_text, 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."
+            total_kw_all_time_label = label("total_kw_all_time", "Total kW (all time)")
+            total_kw_period_label = label("total_kw_period", "Total kW (period)")
+            connector_label = label("connector", "Connector")
+            account_label = label("account", "Account")
+            session_kwh_label = label("session_kwh", "Session kW")
+            session_start_label = label("session_start", "Session start")
+            session_end_label = label("session_end", "Session end")
+            time_label = label("time", "Time")
+            rfid_label = label("rfid_label", "RFID label")
+            no_sessions_period = label(
+                "no_sessions_period",
+                "No charging sessions recorded for the selected period.",
+            )
+            no_sessions_point = label(
+                "no_sessions_point",
+                "No charging sessions recorded for this charge point.",
             )
-            no_sessions_point = gettext(
-                "No charging sessions recorded for this charge point."
+            no_structured_data = label(
+                "no_structured_data",
+                "No structured data is available for this report.",
             )
-            no_structured_data = gettext(
-                "No structured data is available for this report."
+            report_totals_label = label("report_totals", "Report totals")
+            total_kw_period_line = label(
+                "total_kw_period_line", "Total kW during period"
+            )
+            charge_point_label = label("charge_point", "Charge Point")
+            serial_template = (
+                labels.get("charge_point_serial")
+                if isinstance(labels, dict)
+                else None
             )
-            report_totals_label = gettext("Report totals")
-            total_kw_period_line = gettext("Total kW during period")
 
             def format_datetime(value):
                 if not value:
@@ -3837,13 +4069,21 @@ class ClientReport(Entity):
                     if index:
                         story.append(Spacer(1, 0.2 * inch))
 
-                    display_name = evcs.get("display_name") or gettext("Charge Point")
+                    display_name = evcs.get("display_name") or charge_point_label
                     serial_number = evcs.get("serial_number")
                     if serial_number:
-                        header_text = gettext("%(name)s (Serial: %(serial)s)") % {
-                            "name": display_name,
-                            "serial": serial_number,
-                        }
+                        if isinstance(serial_template, str):
+                            try:
+                                header_text = serial_template.format(
+                                    name=display_name, serial=serial_number
+                                )
+                            except (KeyError, IndexError, ValueError):
+                                header_text = serial_template
+                        else:
+                            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))
@@ -3862,11 +4102,11 @@ class ClientReport(Entity):
                         table_data = [
                             [
                                 session_kwh_label,
-                                gettext("Session start"),
-                                gettext("Session end"),
+                                session_start_label,
+                                session_end_label,
                                 time_label,
                                 connector_label,
-                                gettext("RFID label"),
+                                rfid_label,
                                 account_label,
                             ]
                         ]
@@ -4128,6 +4368,11 @@ class Product(Entity):
         return self.name
 
 
+    class Meta:
+        verbose_name = _("Product")
+        verbose_name_plural = _("Products")
+
+
 class AdminHistory(Entity):
     """Record of recently visited admin changelists for a user."""
 
@@ -4737,7 +4982,6 @@ class TodoManager(EntityManager):
     def get_by_natural_key(self, request: str):
         return self.get(request=request)
 
-
 class Todo(Entity):
     """Tasks requested for the Release Manager."""
 
@@ -5037,5 +5281,5 @@ class TOTPDeviceSettings(models.Model):
     is_user_data = models.BooleanField(default=False)
 
     class Meta:
-        verbose_name = _("Authenticator device settings")
-        verbose_name_plural = _("Authenticator device settings")
+        verbose_name = _("Authenticator Device Setting")
+        verbose_name_plural = _("Authenticator Device Settings")

core/system.py

@@ -903,6 +903,21 @@ def _parse_runserver_port(command_line: str) -> int | None:
     return None
 
 
+def _configured_backend_port(base_dir: Path) -> int:
+    lock_file = base_dir / "locks" / "backend_port.lck"
+    try:
+        raw = lock_file.read_text().strip()
+    except OSError:
+        return 8888
+    try:
+        value = int(raw)
+    except (TypeError, ValueError):
+        return 8888
+    if 1 <= value <= 65535:
+        return value
+    return 8888
+
+
 def _detect_runserver_process() -> tuple[bool, int | None]:
     """Return whether the dev server is running and the port if available."""
 
@@ -932,7 +947,7 @@ def _detect_runserver_process() -> tuple[bool, int | None]:
             break
 
     if port is None:
-        port = 8000
+        port = _configured_backend_port(Path(settings.BASE_DIR))
 
     return True, port
 
@@ -981,7 +996,7 @@ def _gather_info() -> dict:
         raw_mode = ""
     mode = raw_mode.lower() or "internal"
     info["mode"] = mode
-    default_port = 8000 if mode == "public" else 8888
+    default_port = _configured_backend_port(base_dir)
     detected_port: int | None = None
 
     screen_file = lock_dir / "screen_mode.lck"