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

core/admin.py

@@ -50,6 +50,7 @@ import uuid
 import requests
 import datetime
 from django.db import IntegrityError, transaction
+from django.db.models import Q
 import calendar
 import re
 from django_object_actions import DjangoObjectActions
@@ -63,7 +64,7 @@ from reportlab.graphics.barcode import qr
 from reportlab.graphics.shapes import Drawing
 from reportlab.lib.styles import getSampleStyleSheet
 from reportlab.platypus import Paragraph, SimpleDocTemplate, Spacer, Table, TableStyle
-from ocpp.models import Transaction
+from ocpp.models import Charger, Transaction
 from ocpp.rfid.utils import build_mode_toggle
 from nodes.models import EmailOutbox
 from .github_helper import GitHubRepositoryError, create_repository_for_package
@@ -2265,199 +2266,15 @@ class ProductAdminForm(forms.ModelForm):
         widgets = {"odoo_product": OdooProductWidget}
 
 
-class ProductFetchWizardForm(forms.Form):
-    name = forms.CharField(label="Name", required=False)
-    default_code = forms.CharField(label="Internal reference", required=False)
-    barcode = forms.CharField(label="Barcode", required=False)
-    renewal_period = forms.IntegerField(
-        label="Renewal period (days)", min_value=1, initial=30
-    )
-
-    def __init__(self, *args, require_search_terms=True, **kwargs):
-        self.require_search_terms = require_search_terms
-        super().__init__(*args, **kwargs)
-
-    def clean(self):
-        cleaned = super().clean()
-        if self.require_search_terms:
-            if not any(
-                cleaned.get(field) for field in ("name", "default_code", "barcode")
-            ):
-                raise forms.ValidationError(
-                    _("Enter at least one field to search for a product.")
-                )
-        return cleaned
-
-    def build_domain(self):
-        domain = []
-        if self.cleaned_data.get("name"):
-            domain.append(("name", "ilike", self.cleaned_data["name"]))
-        if self.cleaned_data.get("default_code"):
-            domain.append(("default_code", "ilike", self.cleaned_data["default_code"]))
-        if self.cleaned_data.get("barcode"):
-            domain.append(("barcode", "ilike", self.cleaned_data["barcode"]))
-        return domain
-
-
 @admin.register(Product)
 class ProductAdmin(EntityModelAdmin):
     form = ProductAdminForm
-    actions = ["fetch_odoo_product", "register_from_odoo"]
+    actions = ["register_from_odoo"]
     change_list_template = "admin/core/product/change_list.html"
 
     def _odoo_profile_admin(self):
         return self.admin_site._registry.get(OdooProfile)
 
-    def _search_odoo_products(self, profile, form):
-        domain = form.build_domain()
-        return profile.execute(
-            "product.product",
-            "search_read",
-            [domain],
-            fields=[
-                "name",
-                "default_code",
-                "barcode",
-                "description_sale",
-            ],
-            limit=50,
-        )
-
-    @admin.action(description="Fetch Odoo Product")
-    def fetch_odoo_product(self, request, queryset):
-        profile = getattr(request.user, "odoo_profile", None)
-        has_credentials = bool(profile and profile.is_verified)
-        profile_admin = self._odoo_profile_admin()
-        profile_url = None
-        if profile_admin is not None:
-            profile_url = profile_admin.get_my_profile_url(request)
-
-        context = {
-            "opts": self.model._meta,
-            "queryset": queryset,
-            "action": "fetch_odoo_product",
-            "has_credentials": has_credentials,
-            "profile_url": profile_url,
-        }
-
-        if not has_credentials:
-            context["credential_error"] = _(
-                "Configure your Odoo employee credentials before fetching products."
-            )
-            return TemplateResponse(
-                request, "admin/core/product/fetch_odoo.html", context
-            )
-
-        is_import = "import" in request.POST
-        form_kwargs = {"require_search_terms": not is_import}
-        if request.method == "POST":
-            form = ProductFetchWizardForm(request.POST, **form_kwargs)
-        else:
-            form = ProductFetchWizardForm()
-
-        results = None
-        selected_product_id = request.POST.get("product_id", "")
-
-        if request.method == "POST" and form.is_valid():
-            try:
-                results = self._search_odoo_products(profile, form)
-            except Exception:
-                logger.exception(
-                    "Failed to fetch Odoo products for user %s (profile_id=%s, host=%s, database=%s)",
-                    getattr(getattr(request, "user", None), "pk", None),
-                    getattr(profile, "pk", None),
-                    getattr(profile, "host", None),
-                    getattr(profile, "database", None),
-                )
-                form.add_error(None, _("Unable to fetch products from Odoo."))
-                results = []
-            else:
-                if is_import:
-                    if not self.has_add_permission(request):
-                        form.add_error(
-                            None, _("You do not have permission to add products.")
-                        )
-                    else:
-                        product_id = request.POST.get("product_id")
-                        if not product_id:
-                            form.add_error(None, _("Select a product to import."))
-                        else:
-                            try:
-                                odoo_id = int(product_id)
-                            except (TypeError, ValueError):
-                                form.add_error(None, _("Invalid product selection."))
-                            else:
-                                match = next(
-                                    (item for item in results if item.get("id") == odoo_id),
-                                    None,
-                                )
-                                if not match:
-                                    form.add_error(
-                                        None,
-                                        _(
-                                            "The selected product was not found. Run the search again."
-                                        ),
-                                    )
-                                else:
-                                    existing = self.model.objects.filter(
-                                        odoo_product__id=odoo_id
-                                    ).first()
-                                    if existing:
-                                        self.message_user(
-                                            request,
-                                            _(
-                                                "Product %(name)s already imported; opening existing record."
-                                            )
-                                            % {"name": existing.name},
-                                            level=messages.WARNING,
-                                        )
-                                        return HttpResponseRedirect(
-                                            reverse(
-                                                "admin:%s_%s_change"
-                                                % (
-                                                    existing._meta.app_label,
-                                                    existing._meta.model_name,
-                                                ),
-                                                args=[existing.pk],
-                                            )
-                                        )
-                                    product = self.model.objects.create(
-                                        name=match.get("name") or f"Odoo Product {odoo_id}",
-                                        description=match.get("description_sale", "") or "",
-                                        renewal_period=form.cleaned_data["renewal_period"],
-                                        odoo_product={
-                                            "id": odoo_id,
-                                            "name": match.get("name", ""),
-                                        },
-                                    )
-                                    self.log_addition(
-                                        request, product, "Imported product from Odoo"
-                                    )
-                                    self.message_user(
-                                        request,
-                                        _("Imported %(name)s from Odoo.")
-                                        % {"name": product.name},
-                                    )
-                                    return HttpResponseRedirect(
-                                        reverse(
-                                            "admin:%s_%s_change"
-                                            % (
-                                                product._meta.app_label,
-                                                product._meta.model_name,
-                                            ),
-                                            args=[product.pk],
-                                        )
-                                    )
-        context.update(
-            {
-                "form": form,
-                "results": results,
-                "selected_product_id": selected_product_id,
-            }
-        )
-        context["media"] = self.media + form.media
-        return TemplateResponse(request, "admin/core/product/fetch_odoo.html", context)
-
     def get_urls(self):
         urls = super().get_urls()
         custom = [
@@ -2506,7 +2323,6 @@ class ProductAdmin(EntityModelAdmin):
             products = profile.execute(
                 "product.product",
                 "search_read",
-                [[]],
                 fields=[
                     "name",
                     "description_sale",
@@ -3615,13 +3431,62 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
         return JsonResponse(result, status=status)
 
 
+class ClientReportRecurrencyFilter(admin.SimpleListFilter):
+    title = "Recurrency"
+    parameter_name = "recurrency"
+
+    def lookups(self, request, model_admin):
+        for value, label in ClientReportSchedule.PERIODICITY_CHOICES:
+            yield (value, label)
+
+    def queryset(self, request, queryset):
+        value = self.value()
+        if not value:
+            return queryset
+        if value == ClientReportSchedule.PERIODICITY_NONE:
+            return queryset.filter(
+                Q(schedule__isnull=True) | Q(schedule__periodicity=value)
+            )
+        return queryset.filter(schedule__periodicity=value)
+
+
 @admin.register(ClientReport)
 class ClientReportAdmin(EntityModelAdmin):
-    list_display = ("created_on", "start_date", "end_date")
+    list_display = (
+        "created_on",
+        "period_range",
+        "owner",
+        "recurrency_display",
+        "total_kw_period_display",
+        "download_link",
+    )
+    list_select_related = ("schedule", "owner")
+    list_filter = ("owner", ClientReportRecurrencyFilter)
     readonly_fields = ("created_on", "data")
 
     change_list_template = "admin/core/clientreport/change_list.html"
 
+    def period_range(self, obj):
+        return str(obj)
+
+    period_range.short_description = "Period"
+
+    def recurrency_display(self, obj):
+        return obj.periodicity_label
+
+    recurrency_display.short_description = "Recurrency"
+
+    def total_kw_period_display(self, obj):
+        return f"{obj.total_kw_period:.2f}"
+
+    total_kw_period_display.short_description = "Total kW (period)"
+
+    def download_link(self, obj):
+        url = reverse("admin:core_clientreport_download", args=[obj.pk])
+        return format_html('<a href="{}">Download</a>', url)
+
+    download_link.short_description = "Download"
+
     class ClientReportForm(forms.Form):
         PERIOD_CHOICES = [
             ("range", "Date range"),
@@ -3657,8 +3522,28 @@ class ClientReportAdmin(EntityModelAdmin):
             label="Month",
             required=False,
             widget=forms.DateInput(attrs={"type": "month"}),
+            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,
@@ -3691,6 +3576,13 @@ class ClientReportAdmin(EntityModelAdmin):
                 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()
@@ -3735,6 +3627,10 @@ class ClientReportAdmin(EntityModelAdmin):
                 emails.append(candidate)
             return emails
 
+        def clean_title(self):
+            title = self.cleaned_data.get("title")
+            return ClientReport.normalize_title(title)
+
     def get_urls(self):
         urls = super().get_urls()
         custom = [
@@ -3743,6 +3639,11 @@ class ClientReportAdmin(EntityModelAdmin):
                 self.admin_site.admin_view(self.generate_view),
                 name="core_clientreport_generate",
             ),
+            path(
+                "generate/action/",
+                self.admin_site.admin_view(self.generate_report),
+                name="core_clientreport_generate_report",
+            ),
             path(
                 "download/<int:report_id>/",
                 self.admin_site.admin_view(self.download_view),
@@ -3763,14 +3664,37 @@ class ClientReportAdmin(EntityModelAdmin):
             enable_emails = form.cleaned_data.get("enable_emails", False)
             disable_emails = not enable_emails
             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"])
+                    self.message_user(
+                        request,
+                        "Consumer report emailed to the selected recipients.",
+                        messages.SUCCESS,
+                    )
             recurrence = form.cleaned_data.get("recurrence")
             if recurrence and recurrence != ClientReportSchedule.PERIODICITY_NONE:
                 schedule = ClientReportSchedule.objects.create(
@@ -3779,12 +3703,16 @@ class ClientReportAdmin(EntityModelAdmin):
                     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"])
                 self.message_user(
                     request,
-                    "Client report schedule created; future reports will be generated automatically.",
+                    "Consumer report schedule created; future reports will be generated automatically.",
                     messages.SUCCESS,
                 )
             if disable_emails:
@@ -3812,45 +3740,44 @@ class ClientReportAdmin(EntityModelAdmin):
                 "report": report,
                 "schedule": schedule,
                 "download_url": download_url,
-                "previous_reports": self._build_report_history(request),
+                "opts": self.model._meta,
             }
         )
         return TemplateResponse(
             request, "admin/core/clientreport/generate.html", context
         )
 
+    def get_changelist_actions(self, request):
+        parent = getattr(super(), "get_changelist_actions", None)
+        actions: list[str] = []
+        if callable(parent):
+            parent_actions = parent(request)
+            if parent_actions:
+                actions.extend(parent_actions)
+        if "generate_report" not in actions:
+            actions.append("generate_report")
+        return actions
+
+    def generate_report(self, request):
+        return HttpResponseRedirect(reverse("admin:core_clientreport_generate"))
+
+    generate_report.label = _("Generate report")
+
     def download_view(self, request, report_id: int):
         report = get_object_or_404(ClientReport, pk=report_id)
         pdf_path = report.ensure_pdf()
         if not pdf_path.exists():
             raise Http404("Report file unavailable")
-        filename = f"consumer-report-{report.start_date}-{report.end_date}.pdf"
+        end_date = report.end_date
+        if hasattr(end_date, "isoformat"):
+            end_date_str = end_date.isoformat()
+        else:  # pragma: no cover - fallback for unexpected values
+            end_date_str = str(end_date)
+        filename = f"consumer-report-{end_date_str}.pdf"
         response = FileResponse(pdf_path.open("rb"), content_type="application/pdf")
         response["Content-Disposition"] = f'attachment; filename="{filename}"'
         return response
 
-    def _build_report_history(self, request):
-        queryset = ClientReport.objects.order_by("-created_on")[:20]
-        history = []
-        for item in queryset:
-            totals = item.rows_for_display.get("totals", {})
-            history.append(
-                {
-                    "instance": item,
-                    "download_url": reverse(
-                        "admin:core_clientreport_download", args=[item.pk]
-                    ),
-                    "email_enabled": not item.disable_emails,
-                    "recipients": item.recipients or [],
-                    "totals": {
-                        "total_kw": totals.get("total_kw", 0.0),
-                        "total_kw_period": totals.get("total_kw_period", 0.0),
-                    },
-                }
-            )
-        return history
-
-
 @admin.register(PackageRelease)
 class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
     change_list_template = "admin/core/packagerelease/change_list.html"

core/backends.py

@@ -217,7 +217,9 @@ class LocalhostAdminBackend(ModelBackend):
             try:
                 ipaddress.ip_address(host)
             except ValueError:
-                if not self._is_test_environment(request):
+                if host.lower() == "localhost":
+                    host = "127.0.0.1"
+                elif not self._is_test_environment(request):
                     return None
             forwarded = request.META.get("HTTP_X_FORWARDED_FOR")
             if forwarded: