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

core/admin.py

@@ -43,6 +43,7 @@ from django.utils import timezone, translation
 from django.utils.formats import date_format
 from django.utils.dateparse import parse_datetime
 from django.utils.html import format_html
+from django.utils.text import slugify
 from django.utils.translation import gettext_lazy as _, ngettext
 from django.forms.models import BaseInlineFormSet
 import json
@@ -813,6 +814,7 @@ class SecurityGroupAdmin(DjangoGroupAdmin):
     form = SecurityGroupAdminForm
     fieldsets = ((None, {"fields": ("name", "parent", "users", "permissions")}),)
     filter_horizontal = ("permissions",)
+    search_fields = ("name", "parent__name")
 
 
 class InviteLeadAdmin(EntityModelAdmin):
@@ -881,6 +883,82 @@ class EnergyAccountRFIDInline(admin.TabularInline):
     verbose_name_plural = "RFIDs"
 
 
+class UserChangeRFIDForm(forms.ModelForm):
+    """Admin change form exposing login RFID assignment."""
+
+    login_rfid = forms.ModelChoiceField(
+        label=_("Login RFID"),
+        queryset=RFID.objects.none(),
+        required=False,
+        help_text=_("Assign an RFID card to this user for RFID logins."),
+    )
+
+    class Meta:
+        model = User
+        fields = "__all__"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        user = self.instance
+        field = self.fields["login_rfid"]
+        account = getattr(user, "energy_account", None)
+        if account is not None:
+            queryset = RFID.objects.filter(
+                Q(energy_accounts__isnull=True) | Q(energy_accounts=account)
+            )
+            current = account.rfids.order_by("label_id").first()
+            if current:
+                field.initial = current.pk
+        else:
+            queryset = RFID.objects.filter(energy_accounts__isnull=True)
+        field.queryset = queryset.order_by("label_id")
+        field.empty_label = _("Keep current assignment")
+
+    def _ensure_energy_account(self, user):
+        account = getattr(user, "energy_account", None)
+        if account is not None:
+            if account.user_id != user.pk:
+                account.user = user
+                account.save(update_fields=["user"])
+            return account
+        account = EnergyAccount.objects.filter(user=user).first()
+        if account is not None:
+            if account.user_id != user.pk:
+                account.user = user
+                account.save(update_fields=["user"])
+            return account
+        base_slug = slugify(
+            user.username
+            or user.get_full_name()
+            or user.email
+            or (str(user.pk) if user.pk is not None else "")
+        )
+        if not base_slug:
+            base_slug = f"user-{uuid.uuid4().hex[:8]}"
+        base_name = base_slug.upper()
+        candidate = base_name
+        suffix = 1
+        while EnergyAccount.objects.filter(name=candidate).exists():
+            suffix += 1
+            candidate = f"{base_name}-{suffix}"
+        return EnergyAccount.objects.create(user=user, name=candidate)
+
+    def save(self, commit=True):
+        user = super().save(commit)
+        rfid = self.cleaned_data.get("login_rfid")
+        if not rfid:
+            return user
+        account = self._ensure_energy_account(user)
+        if account.pk is None:
+            account.save()
+        other_accounts = list(rfid.energy_accounts.exclude(pk=account.pk))
+        if other_accounts:
+            rfid.energy_accounts.remove(*other_accounts)
+        if not account.rfids.filter(pk=rfid.pk).exists():
+            account.rfids.add(rfid)
+        return user
+
+
 def _raw_instance_value(instance, field_name):
     """Return the stored value for ``field_name`` without resolving sigils."""
 
@@ -978,6 +1056,15 @@ class OpenPayProfileAdminForm(forms.ModelForm):
         required=False,
         help_text="Leave blank to keep the current secret.",
     )
+    paypal_client_secret = forms.CharField(
+        widget=forms.PasswordInput(render_value=True),
+        required=False,
+        help_text="Leave blank to keep the current secret.",
+    )
+    paypal_webhook_id = forms.CharField(
+        required=False,
+        help_text="Leave blank to keep the current webhook identifier.",
+    )
 
     class Meta:
         model = OpenPayProfile
@@ -985,13 +1072,43 @@ class OpenPayProfileAdminForm(forms.ModelForm):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
+        openpay_help = _(
+            "Provide merchant ID, public and private keys, and webhook secret from OpenPay."
+        )
+        self.fields["merchant_id"].help_text = openpay_help
+        self.fields["public_key"].help_text = _(
+            "OpenPay public key used for browser integrations."
+        )
+        self.fields["private_key"].help_text = _(
+            "OpenPay private key used for server-side requests. Leave blank to keep the current key."
+        )
+        self.fields["webhook_secret"].help_text = _(
+            "Secret used to sign OpenPay webhooks. Leave blank to keep the current secret."
+        )
+        self.fields["is_production"].help_text = _(
+            "Enable to send requests to OpenPay's live environment."
+        )
+        self.fields["default_processor"].help_text = _(
+            "Select which configured processor to try first when charging."
+        )
+        self.fields["paypal_client_id"].help_text = _(
+            "PayPal REST client ID for your application."
+        )
+        self.fields["paypal_client_secret"].help_text = _(
+            "PayPal REST client secret. Leave blank to keep the current secret."
+        )
+        self.fields["paypal_webhook_id"].help_text = _(
+            "PayPal webhook ID used to validate notifications. Leave blank to keep the current webhook identifier."
+        )
+        self.fields["paypal_is_production"].help_text = _(
+            "Enable to send requests to PayPal's live environment."
+        )
+
         if self.instance.pk:
-            for field in ("private_key", "webhook_secret"):
+            for field in ("private_key", "webhook_secret", "paypal_client_secret", "paypal_webhook_id"):
                 if field in self.fields:
                     self.fields[field].initial = ""
                     self.initial[field] = ""
-        else:
-            self.fields["private_key"].required = True
 
     def clean_private_key(self):
         key = self.cleaned_data.get("private_key")
@@ -1005,11 +1122,31 @@ class OpenPayProfileAdminForm(forms.ModelForm):
             return keep_existing("webhook_secret")
         return secret
 
+    def clean_paypal_client_secret(self):
+        secret = self.cleaned_data.get("paypal_client_secret")
+        if not secret and self.instance.pk:
+            return keep_existing("paypal_client_secret")
+        return secret
+
+    def clean_paypal_webhook_id(self):
+        identifier = self.cleaned_data.get("paypal_webhook_id")
+        if identifier == "" and self.instance.pk:
+            return keep_existing("paypal_webhook_id")
+        return identifier
+
     def _post_clean(self):
         super()._post_clean()
         _restore_sigil_values(
             self,
-            ["merchant_id", "private_key", "public_key", "webhook_secret"],
+            [
+                "merchant_id",
+                "private_key",
+                "public_key",
+                "webhook_secret",
+                "paypal_client_id",
+                "paypal_client_secret",
+                "paypal_webhook_id",
+            ],
         )
 
 
@@ -1232,7 +1369,7 @@ class OdooProfileInlineForm(ProfileFormMixin, OdooProfileAdminForm):
         ]
         if provided and missing:
             raise forms.ValidationError(
-                "Provide host, database, username, and password to create an Odoo employee.",
+                "Provide host, database, username, and password to create a CRM employee.",
             )
 
         return cleaned
@@ -1249,19 +1386,51 @@ class OpenPayProfileInlineForm(ProfileFormMixin, OpenPayProfileAdminForm):
         if cleaned.get("DELETE") or self.errors:
             return cleaned
 
-        required = ("merchant_id", "private_key", "public_key")
-        provided = [
-            name for name in required if not self._is_empty_value(cleaned.get(name))
-        ]
-        missing = [
-            name for name in required if self._is_empty_value(cleaned.get(name))
-        ]
-        if provided and missing:
+        def _has_value(name: str) -> bool:
+            value = cleaned.get(name)
+            if isinstance(value, KeepExistingValue):
+                return bool(getattr(self.instance, name))
+            return not self._is_empty_value(value)
+
+        openpay_fields = ("merchant_id", "private_key", "public_key")
+        openpay_provided = [name for name in openpay_fields if _has_value(name)]
+        openpay_missing = [name for name in openpay_fields if not _has_value(name)]
+        if openpay_provided and openpay_missing:
             raise forms.ValidationError(
                 _(
                     "Provide merchant ID, private key, and public key to configure OpenPay."
                 )
             )
+
+        paypal_fields = ("paypal_client_id", "paypal_client_secret")
+        paypal_provided = [name for name in paypal_fields if _has_value(name)]
+        paypal_missing = [name for name in paypal_fields if not _has_value(name)]
+        if paypal_provided and paypal_missing:
+            raise forms.ValidationError(
+                _("Provide PayPal client ID and client secret to configure PayPal.")
+            )
+
+        has_openpay = len(openpay_provided) == len(openpay_fields)
+        has_paypal = len(paypal_provided) == len(paypal_fields)
+
+        if not has_openpay and not has_paypal:
+            raise forms.ValidationError(
+                _("Provide OpenPay or PayPal credentials to configure a payment processor.")
+            )
+
+        default_processor = cleaned.get("default_processor") or OpenPayProfile.PROCESSOR_OPENPAY
+        if default_processor == OpenPayProfile.PROCESSOR_OPENPAY and not has_openpay:
+            raise forms.ValidationError(
+                _(
+                    "OpenPay must be fully configured or select PayPal as the default processor."
+                )
+            )
+        if default_processor == OpenPayProfile.PROCESSOR_PAYPAL and not has_paypal:
+            raise forms.ValidationError(
+                _(
+                    "PayPal must be fully configured or select OpenPay as the default processor."
+                )
+            )
         return cleaned
 
 
@@ -1360,6 +1529,7 @@ PROFILE_INLINE_CONFIG = {
                 None,
                 {
                     "fields": (
+                        "crm",
                         "host",
                         "database",
                         "username",
@@ -1368,7 +1538,7 @@ PROFILE_INLINE_CONFIG = {
                 },
             ),
             (
-                "Odoo Employee",
+                "CRM Employee",
                 {
                     "fields": ("verified_on", "odoo_uid", "name", "email"),
                 },
@@ -1556,12 +1726,25 @@ class UserPhoneNumberInline(admin.TabularInline):
 
 
 class UserAdmin(UserDatumAdminMixin, DjangoUserAdmin):
+    form = UserChangeRFIDForm
     fieldsets = _append_operate_as(DjangoUserAdmin.fieldsets)
     add_fieldsets = _append_operate_as(DjangoUserAdmin.add_fieldsets)
     inlines = USER_PROFILE_INLINES + [UserPhoneNumberInline]
     change_form_template = "admin/user_profile_change_form.html"
     _skip_entity_user_datum = True
 
+    def get_fieldsets(self, request, obj=None):
+        fieldsets = list(super().get_fieldsets(request, obj))
+        if obj is not None and fieldsets:
+            name, options = fieldsets[0]
+            fields = list(options.get("fields", ()))
+            if "login_rfid" not in fields:
+                fields.append("login_rfid")
+                options = options.copy()
+                options["fields"] = tuple(fields)
+                fieldsets[0] = (name, options)
+        return fieldsets
+
     def _get_operate_as_profile_template(self):
         opts = self.model._meta
         try:
@@ -1769,17 +1952,18 @@ class SocialProfileAdmin(
 class OdooProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin):
     change_form_template = "django_object_actions/change_form.html"
     form = OdooProfileAdminForm
-    list_display = ("owner", "host", "database", "verified_on")
+    list_display = ("owner", "host", "database", "credentials_ok", "verified_on")
+    list_filter = ("crm",)
     readonly_fields = ("verified_on", "odoo_uid", "name", "email")
     actions = ["verify_credentials"]
     change_actions = ["verify_credentials_action", "my_profile_action"]
     changelist_actions = ["my_profile", "generate_quote_report"]
     fieldsets = (
         ("Owner", {"fields": ("user", "group")}),
-        ("Configuration", {"fields": ("host", "database")}),
+        ("Configuration", {"fields": ("crm", "host", "database")}),
         ("Credentials", {"fields": ("username", "password")}),
         (
-            "Odoo Employee",
+            "CRM Employee",
             {"fields": ("verified_on", "odoo_uid", "name", "email")},
         ),
     )
@@ -1789,6 +1973,10 @@ class OdooProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdm
 
     owner.short_description = "Owner"
 
+    @admin.display(description=_("Credentials OK"), boolean=True)
+    def credentials_ok(self, obj):
+        return bool(obj.password) and obj.is_verified
+
     def _verify_credentials(self, request, profile):
         try:
             profile.verify()
@@ -1820,15 +2008,47 @@ class OdooProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdm
 class OpenPayProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin):
     change_form_template = "django_object_actions/change_form.html"
     form = OpenPayProfileAdminForm
-    list_display = ("owner", "merchant_id", "environment", "verified_on")
+    list_display = ("owner", "default_processor_display", "environment", "verified_on")
     readonly_fields = ("verified_on", "verification_reference")
     actions = ["verify_credentials"]
     change_actions = ["verify_credentials_action", "my_profile_action"]
     changelist_actions = ["my_profile"]
     fieldsets = (
         (_("Owner"), {"fields": ("user", "group")}),
-        (_("Gateway"), {"fields": ("merchant_id", "public_key", "is_production")}),
-        (_("Credentials"), {"fields": ("private_key", "webhook_secret")}),
+        (
+            _("Default Processor"),
+            {
+                "fields": ("default_processor",),
+                "description": _(
+                    "Choose which configured processor to contact first when processing payments."
+                ),
+            },
+        ),
+        (
+            _("OpenPay"),
+            {
+                "fields": (
+                    "merchant_id",
+                    "public_key",
+                    "private_key",
+                    "webhook_secret",
+                    "is_production",
+                ),
+                "description": _("Configure OpenPay merchant access."),
+            },
+        ),
+        (
+            _("PayPal"),
+            {
+                "fields": (
+                    "paypal_client_id",
+                    "paypal_client_secret",
+                    "paypal_webhook_id",
+                    "paypal_is_production",
+                ),
+                "description": _("Configure PayPal REST API access."),
+            },
+        ),
         (
             _("Verification"),
             {"fields": ("verified_on", "verification_reference")},
@@ -1839,12 +2059,23 @@ class OpenPayProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModel
     def owner(self, obj):
         return obj.owner_display()
 
+    @admin.display(description=_("Default Processor"))
+    def default_processor_display(self, obj):
+        return obj.get_default_processor_display()
+
     @admin.display(description=_("Environment"))
     def environment(self, obj):
-        return _("Production") if obj.is_production else _("Sandbox")
+        if obj.default_processor == obj.PROCESSOR_PAYPAL:
+            return _("PayPal Production") if obj.paypal_is_production else _("PayPal Sandbox")
+        return _("OpenPay Production") if obj.is_production else _("OpenPay Sandbox")
 
     def _verify_credentials(self, request, profile):
-        owner = profile.owner_display() or profile.merchant_id
+        owner = (
+            profile.owner_display()
+            or profile.merchant_id
+            or profile.paypal_client_id
+            or _("Payment Processor")
+        )
         try:
             profile.verify()
         except ValidationError as exc:
@@ -2315,7 +2546,7 @@ class ProductAdmin(EntityModelAdmin):
         profile = getattr(request.user, "odoo_profile", None)
         if not profile or not profile.is_verified:
             context["credential_error"] = _(
-                "Configure your Odoo employee credentials before registering products."
+                "Configure your CRM employee credentials before registering products."
             )
             return context, None
 
@@ -2523,6 +2754,12 @@ class RFIDResource(resources.ModelResource):
         account_column = account_column_for_field(account_field)
         self.fields["energy_accounts"].column_name = account_column
 
+    def get_queryset(self):
+        manager = getattr(self._meta.model, "all_objects", None)
+        if manager is not None:
+            return manager.all()
+        return super().get_queryset()
+
     def dehydrate_energy_accounts(self, obj):
         return serialize_accounts(obj, self.account_field)
 
@@ -2536,6 +2773,11 @@ class RFIDResource(resources.ModelResource):
         else:
             instance.energy_accounts.clear()
 
+    def before_save_instance(self, instance, row, **kwargs):
+        if getattr(instance, "is_deleted", False):
+            instance.is_deleted = False
+        super().before_save_instance(instance, row, **kwargs)
+
     class Meta:
         model = RFID
         fields = (

core/apps.py

@@ -38,6 +38,7 @@ class CoreConfig(AppConfig):
             patch_admin_sigil_builder_view,
             generate_model_sigils,
         )
+        from .celery_utils import normalize_periodic_task_name
         from .admin_history import patch_admin_history
 
         from django_otp.plugins.otp_totp.models import TOTPDevice as OTP_TOTPDevice
@@ -222,8 +223,11 @@ class CoreConfig(AppConfig):
                     schedule, _ = IntervalSchedule.objects.get_or_create(
                         every=1, period=IntervalSchedule.HOURS
                     )
-                    PeriodicTask.objects.get_or_create(
-                        name="poll_email_collectors",
+                    task_name = normalize_periodic_task_name(
+                        PeriodicTask.objects, "poll_email_collectors"
+                    )
+                    PeriodicTask.objects.update_or_create(
+                        name=task_name,
                         defaults={
                             "interval": schedule,
                             "task": "core.tasks.poll_email_collectors",

core/celery_utils.py

@@ -0,0 +1,73 @@
+"""Utilities for working with Celery periodic task names."""
+
+from __future__ import annotations
+
+import re
+from typing import Set
+
+from django.db import transaction
+from django.db.utils import IntegrityError
+
+
+def slugify_task_name(name: str) -> str:
+    """Return a slugified task name using dashes.
+
+    Celery stores periodic task names in the database and historically these
+    values included underscores or dotted module paths. The scheduler UI reads
+    these values directly, so we collapse consecutive underscores or dots into a
+    single dash to keep them human readable while remaining unique.
+    """
+
+    slug = re.sub(r"[._]+", "-", name)
+    # Collapse any accidental duplicate separators that may result from the
+    # replacement so ``foo__bar`` and ``foo..bar`` both become ``foo-bar``.
+    slug = re.sub(r"-{2,}", "-", slug)
+    return slug
+
+
+def periodic_task_name_variants(name: str) -> Set[str]:
+    """Return legacy and slugified variants for a periodic task name."""
+
+    slug = slugify_task_name(name)
+    if slug == name:
+        return {name}
+    return {name, slug}
+
+
+def normalize_periodic_task_name(manager, name: str) -> str:
+    """Ensure the stored periodic task name matches the slugified form.
+
+    The helper renames any rows that still use the legacy value so that follow-up
+    ``update_or_create`` calls keep working without leaving duplicate tasks in
+    the scheduler. When a conflicting slug already exists we keep the slugged
+    version and remove the legacy entry.
+    """
+
+    slug = slugify_task_name(name)
+    if slug == name:
+        return slug
+
+    for task in manager.filter(name=name):
+        conflict = manager.filter(name=slug).exclude(pk=task.pk).first()
+        if conflict:
+            # Preserve foreign key references when possible before removing the
+            # legacy row.
+            related_attr = getattr(task, "client_report_schedule", None)
+            if related_attr and getattr(conflict, "client_report_schedule", None) is None:
+                related_attr.periodic_task = conflict
+                related_attr.save(update_fields=["periodic_task"])
+            task.delete()
+            continue
+
+        task.name = slug
+        try:
+            with transaction.atomic():
+                task.save(update_fields=["name"])
+        except IntegrityError:
+            # Another process may have created the slug in between the select and
+            # the update. Fall back to deleting the legacy row to avoid duplicate
+            # scheduler entries.
+            task.refresh_from_db()
+            if task.name != slug:
+                task.delete()
+    return slug