arthexis 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

core/admin.py

@@ -1,7 +1,8 @@
 from django import forms
 from django.contrib import admin
 from django.contrib.admin.widgets import RelatedFieldWidgetWrapper
-from django.urls import path, reverse
+from django.urls import NoReverseMatch, path, reverse
+from urllib.parse import urlencode
 from django.shortcuts import redirect, render
 from django.http import JsonResponse, HttpResponseBase, HttpResponseRedirect
 from django.template.response import TemplateResponse
@@ -61,7 +62,15 @@ from .models import (
     Todo,
     hash_key,
 )
-from .user_data import EntityModelAdmin, delete_user_fixture, dump_user_fixture
+from .user_data import (
+    EntityModelAdmin,
+    UserDatumAdminMixin,
+    delete_user_fixture,
+    dump_user_fixture,
+    _fixture_path,
+    _resolve_fixture_user,
+    _user_allows_user_data,
+)
 from .widgets import OdooProductWidget
 from .mcp import process as mcp_process
 
@@ -161,11 +170,97 @@ class SaveBeforeChangeAction(DjangoObjectActions):
         return super().response_change(request, obj)
 
 
+class ProfileAdminMixin:
+    """Reusable actions for profile-bound admin classes."""
+
+    def _resolve_my_profile_target(self, request):
+        opts = self.model._meta
+        changelist_url = reverse(
+            f"admin:{opts.app_label}_{opts.model_name}_changelist"
+        )
+        user = getattr(request, "user", None)
+        if not getattr(user, "is_authenticated", False):
+            return (
+                changelist_url,
+                _("You must be logged in to manage your profile."),
+                messages.ERROR,
+            )
+
+        profile = self.model._default_manager.filter(user=user).first()
+        if profile is not None:
+            permission_check = getattr(self, "has_view_or_change_permission", None)
+            has_permission = (
+                permission_check(request, obj=profile)
+                if callable(permission_check)
+                else self.has_change_permission(request, obj=profile)
+            )
+            if has_permission:
+                change_url = reverse(
+                    f"admin:{opts.app_label}_{opts.model_name}_change",
+                    args=[profile.pk],
+                )
+                return change_url, None, None
+            return (
+                changelist_url,
+                _("You do not have permission to view this profile."),
+                messages.ERROR,
+            )
+
+        if self.has_add_permission(request):
+            add_url = reverse(f"admin:{opts.app_label}_{opts.model_name}_add")
+            params = {}
+            user_id = getattr(user, "pk", None)
+            if user_id:
+                params["user"] = user_id
+            if params:
+                add_url = f"{add_url}?{urlencode(params)}"
+            return add_url, None, None
+
+        return (
+            changelist_url,
+            _("You do not have permission to create this profile."),
+            messages.ERROR,
+        )
+
+    def get_my_profile_url(self, request):
+        url, _message, _level = self._resolve_my_profile_target(request)
+        return url
+
+    def _redirect_to_my_profile(self, request):
+        target_url, message, level = self._resolve_my_profile_target(request)
+        if message:
+            self.message_user(request, message, level=level)
+        return HttpResponseRedirect(target_url)
+
+    @admin.action(description=_("Active Profile"))
+    def my_profile(self, request, queryset=None):
+        return self._redirect_to_my_profile(request)
+
+    def my_profile_action(self, request, obj=None):
+        return self._redirect_to_my_profile(request)
+
+    my_profile_action.label = _("Active Profile")
+    my_profile_action.short_description = _("Active Profile")
+
+    def get_actions(self, request):
+        actions = super().get_actions(request)
+        if "my_profile" not in actions:
+            action = getattr(self, "my_profile", None)
+            if action is not None:
+                actions["my_profile"] = (
+                    action,
+                    "my_profile",
+                    getattr(action, "short_description", _("Active Profile")),
+                )
+        return actions
+
+
 @admin.register(ExperienceReference)
 class ReferenceAdmin(EntityModelAdmin):
     list_display = (
         "alt_text",
         "content_type",
+        "header",
         "footer",
         "visibility",
         "author",
@@ -182,6 +277,7 @@ class ReferenceAdmin(EntityModelAdmin):
         "features",
         "sites",
         "include_in_footer",
+        "show_in_header",
         "footer_visibility",
         "transaction_uuid",
         "author",
@@ -200,6 +296,10 @@ class ReferenceAdmin(EntityModelAdmin):
     def footer(self, obj):
         return obj.include_in_footer
 
+    @admin.display(description="Header", boolean=True, ordering="show_in_header")
+    def header(self, obj):
+        return obj.show_in_header
+
     @admin.display(description="Visibility", ordering="footer_visibility")
     def visibility(self, obj):
         return obj.get_footer_visibility_display()
@@ -260,11 +360,12 @@ class ReleaseManagerAdminForm(forms.ModelForm):
 
 
 @admin.register(ReleaseManager)
-class ReleaseManagerAdmin(SaveBeforeChangeAction, EntityModelAdmin):
+class ReleaseManagerAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin):
     form = ReleaseManagerAdminForm
     list_display = ("owner", "pypi_username", "pypi_url")
     actions = ["test_credentials"]
-    change_actions = ["test_credentials_action"]
+    change_actions = ["test_credentials_action", "my_profile_action"]
+    changelist_actions = ["my_profile"]
     fieldsets = (
         ("Owner", {"fields": ("user", "group")}),
         (
@@ -325,9 +426,6 @@ class ReleaseManagerAdmin(SaveBeforeChangeAction, EntityModelAdmin):
                 request, f"{manager} credentials check failed: {exc}", messages.ERROR
             )
 
-    def get_model_perms(self, request):
-        return {}
-
 
 @admin.register(Package)
 class PackageAdmin(SaveBeforeChangeAction, EntityModelAdmin):
@@ -338,7 +436,6 @@ class PackageAdmin(SaveBeforeChangeAction, EntityModelAdmin):
         "release_manager",
         "is_active",
     )
-    actions = ["prepare_next_release"]
     change_actions = ["prepare_next_release_action"]
 
     def _prepare(self, request, package):
@@ -395,13 +492,6 @@ class PackageAdmin(SaveBeforeChangeAction, EntityModelAdmin):
             return redirect("admin:core_package_changelist")
         return self._prepare(request, package)
 
-    @admin.action(description="Prepare next Release")
-    def prepare_next_release(self, request, queryset):
-        if queryset.count() != 1:
-            self.message_user(request, "Select exactly one package", messages.ERROR)
-            return
-        return self._prepare(request, queryset.first())
-
     def prepare_next_release_action(self, request, obj):
         return self._prepare(request, obj)
 
@@ -617,6 +707,17 @@ class EmailInboxAdminForm(forms.ModelForm):
 class ProfileInlineFormSet(BaseInlineFormSet):
     """Hide deletion controls and allow implicit removal when empty."""
 
+    @classmethod
+    def get_default_prefix(cls):
+        prefix = super().get_default_prefix()
+        if prefix:
+            return prefix
+        model_name = cls.model._meta.model_name
+        remote_field = getattr(cls.fk, "remote_field", None)
+        if remote_field is not None and getattr(remote_field, "one_to_one", False):
+            return model_name
+        return f"{model_name}_set"
+
     def add_fields(self, form, index):
         super().add_fields(form, index)
         if "DELETE" in form.fields:
@@ -974,21 +1075,61 @@ class UserPhoneNumberInline(admin.TabularInline):
     fields = ("number", "priority")
 
 
-class UserAdmin(DjangoUserAdmin):
+class UserAdmin(UserDatumAdminMixin, DjangoUserAdmin):
     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_operate_as_profile_template(self):
+        opts = self.model._meta
+        try:
+            return reverse(
+                f"{self.admin_site.name}:{opts.app_label}_{opts.model_name}_change",
+                args=["__ID__"],
+            )
+        except NoReverseMatch:
+            user_opts = User._meta
+            try:
+                return reverse(
+                    f"{self.admin_site.name}:{user_opts.app_label}_{user_opts.model_name}_change",
+                    args=["__ID__"],
+                )
+            except NoReverseMatch:
+                return None
 
     def render_change_form(
         self, request, context, add=False, change=False, form_url="", obj=None
     ):
-        context = super().render_change_form(
+        response = super().render_change_form(
             request, context, add=add, change=change, form_url=form_url, obj=obj
         )
-        context["show_user_datum"] = False
-        context["show_seed_datum"] = False
-        return context
+        if isinstance(response, dict):
+            context_data = response
+        else:
+            context_data = getattr(response, "context_data", None)
+        if context_data is not None:
+            context_data["show_user_datum"] = False
+            context_data["show_seed_datum"] = False
+            context_data["show_save_as_copy"] = False
+        operate_as_user = None
+        operate_as_template = self._get_operate_as_profile_template()
+        operate_as_url = None
+        if obj and getattr(obj, "operate_as_id", None):
+            try:
+                operate_as_user = obj.operate_as
+            except User.DoesNotExist:
+                operate_as_user = None
+            if operate_as_user and operate_as_template:
+                operate_as_url = operate_as_template.replace(
+                    "__ID__", str(operate_as_user.pk)
+                )
+        if context_data is not None:
+            context_data["operate_as_user"] = operate_as_user
+            context_data["operate_as_profile_url_template"] = operate_as_template
+            context_data["operate_as_profile_url"] = operate_as_url
+        return response
 
     def get_inline_instances(self, request, obj=None):
         inline_instances = super().get_inline_instances(request, obj)
@@ -1035,6 +1176,25 @@ class UserAdmin(DjangoUserAdmin):
             should_store = bool(inline_form.cleaned_data.get("user_datum"))
             self._update_profile_fixture(instance, owner_user, store=should_store)
 
+    def save_model(self, request, obj, form, change):
+        super().save_model(request, obj, form, change)
+        if not getattr(obj, "pk", None):
+            return
+        target_user = _resolve_fixture_user(obj, obj)
+        allow_user_data = _user_allows_user_data(target_user)
+        if request.POST.get("_user_datum") == "on":
+            type(obj).all_objects.filter(pk=obj.pk).update(is_user_data=False)
+            obj.is_user_data = False
+            delete_user_fixture(obj, target_user)
+            self.message_user(
+                request,
+                _("User data for user accounts is managed through the profile sections."),
+            )
+        elif obj.is_user_data:
+            type(obj).all_objects.filter(pk=obj.pk).update(is_user_data=False)
+            obj.is_user_data = False
+            delete_user_fixture(obj, target_user)
+
 
 class EmailCollectorInline(admin.TabularInline):
     model = EmailCollector
@@ -1047,16 +1207,20 @@ class EmailCollectorAdmin(EntityModelAdmin):
 
 
 @admin.register(OdooProfile)
-class OdooProfileAdmin(SaveBeforeChangeAction, EntityModelAdmin):
+class OdooProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin):
     change_form_template = "django_object_actions/change_form.html"
     form = OdooProfileAdminForm
     list_display = ("owner", "host", "database", "verified_on")
     readonly_fields = ("verified_on", "odoo_uid", "name", "email")
     actions = ["verify_credentials"]
-    change_actions = ["verify_credentials_action"]
+    change_actions = ["verify_credentials_action", "my_profile_action"]
+    changelist_actions = ["my_profile"]
     fieldsets = (
         ("Owner", {"fields": ("user", "group")}),
-        (None, {"fields": ("host", "database", "username", "password")}),
+        (
+            "Configuration",
+            {"fields": ("host", "database", "username", "password")},
+        ),
         (
             "Odoo Employee",
             {"fields": ("verified_on", "odoo_uid", "name", "email")},
@@ -1088,9 +1252,6 @@ class OdooProfileAdmin(SaveBeforeChangeAction, EntityModelAdmin):
     verify_credentials_action.label = "Test credentials"
     verify_credentials_action.short_description = "Test credentials"
 
-    def get_model_perms(self, request):
-        return {}
-
 
 class EmailSearchForm(forms.Form):
     subject = forms.CharField(
@@ -1107,11 +1268,12 @@ class EmailSearchForm(forms.Form):
     )
 
 
-class EmailInboxAdmin(SaveBeforeChangeAction, EntityModelAdmin):
+class EmailInboxAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin):
     form = EmailInboxAdminForm
     list_display = ("owner_label", "username", "host", "protocol")
     actions = ["test_connection", "search_inbox", "test_collectors"]
-    change_actions = ["test_collectors_action"]
+    change_actions = ["test_collectors_action", "my_profile_action"]
+    changelist_actions = ["my_profile"]
     change_form_template = "admin/core/emailinbox/change_form.html"
     inlines = [EmailCollectorInline]
 
@@ -1244,12 +1406,16 @@ class EmailInboxAdmin(SaveBeforeChangeAction, EntityModelAdmin):
 
 
 @admin.register(AssistantProfile)
-class AssistantProfileAdmin(EntityModelAdmin):
+class AssistantProfileAdmin(
+    ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin
+):
     list_display = ("owner", "created_at", "last_used_at", "is_active")
     readonly_fields = ("user_key_hash", "created_at", "last_used_at")
 
     change_form_template = "admin/workgroupassistantprofile_change_form.html"
     change_list_template = "admin/assistantprofile_change_list.html"
+    change_actions = ["my_profile_action"]
+    changelist_actions = ["my_profile"]
     fieldsets = (
         ("Owner", {"fields": ("user", "group")}),
         (
@@ -1406,9 +1572,6 @@ class AssistantProfileAdmin(EntityModelAdmin):
         self.message_user(request, msg, level=level)
         return self._redirect_to_changelist()
 
-    def get_model_perms(self, request):
-        return {}
-
 
 class EnergyCreditInline(admin.TabularInline):
     model = EnergyCredit
@@ -1614,9 +1777,192 @@ 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"]
+
+    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:
+                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)
 
 
 class RFIDResource(resources.ModelResource):
@@ -1756,30 +2102,39 @@ class ClientReportAdmin(EntityModelAdmin):
         ]
         RECURRENCE_CHOICES = ClientReportSchedule.PERIODICITY_CHOICES
         period = forms.ChoiceField(
-            choices=PERIOD_CHOICES, widget=forms.RadioSelect, initial="range"
+            choices=PERIOD_CHOICES,
+            widget=forms.RadioSelect,
+            initial="range",
+            help_text="Choose how the reporting window will be calculated.",
         )
         start = forms.DateField(
             label="Start date",
             required=False,
             widget=forms.DateInput(attrs={"type": "date"}),
+            help_text="First day included when using a custom date range.",
         )
         end = forms.DateField(
             label="End date",
             required=False,
             widget=forms.DateInput(attrs={"type": "date"}),
+            help_text="Last day included when using a custom date range.",
         )
         week = forms.CharField(
             label="Week",
             required=False,
             widget=forms.TextInput(attrs={"type": "week"}),
+            help_text="Generates the report for the ISO week that you select.",
         )
         month = forms.DateField(
             label="Month",
             required=False,
             widget=forms.DateInput(attrs={"type": "month"}),
+            help_text="Generates the report for the calendar month that you select.",
         )
         owner = forms.ModelChoiceField(
-            queryset=get_user_model().objects.all(), required=False
+            queryset=get_user_model().objects.all(),
+            required=False,
+            help_text="Sets who owns the report schedule and is listed as the requestor.",
         )
         destinations = forms.CharField(
             label="Email destinations",
@@ -1791,6 +2146,7 @@ class ClientReportAdmin(EntityModelAdmin):
             label="Recurrency",
             choices=RECURRENCE_CHOICES,
             initial=ClientReportSchedule.PERIODICITY_NONE,
+            help_text="Defines how often the report should be generated automatically.",
         )
         disable_emails = forms.BooleanField(
             label="Disable email delivery",
@@ -1915,7 +2271,7 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
     list_display_links = ("version",)
     actions = ["publish_release", "validate_releases"]
     change_actions = ["publish_release_action"]
-    changelist_actions = ["refresh_from_pypi"]
+    changelist_actions = ["refresh_from_pypi", "prepare_next_release"]
     readonly_fields = ("pypi_url", "is_current", "revision")
     fields = (
         "package",
@@ -1977,6 +2333,16 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
     refresh_from_pypi.label = "Refresh from PyPI"
     refresh_from_pypi.short_description = "Refresh from PyPI"
 
+    def prepare_next_release(self, request, queryset):
+        package = Package.objects.filter(is_active=True).first()
+        if not package:
+            self.message_user(request, "No active package", messages.ERROR)
+            return redirect("admin:core_packagerelease_changelist")
+        return PackageAdmin._prepare(self, request, package)
+
+    prepare_next_release.label = "Prepare next Release"
+    prepare_next_release.short_description = "Prepare next release"
+
     def _publish_release(self, request, release):
         try:
             release.full_clean()

core/apps.py

@@ -105,6 +105,7 @@ class CoreConfig(AppConfig):
         lock = Path(settings.BASE_DIR) / "locks" / "celery.lck"
 
         if lock.exists():
+            from .auto_upgrade import ensure_auto_upgrade_periodic_task
 
             def ensure_email_collector_task(**kwargs):
                 try:  # pragma: no cover - optional dependency
@@ -131,6 +132,8 @@ class CoreConfig(AppConfig):
                     pass
 
             post_migrate.connect(ensure_email_collector_task, sender=self)
+            post_migrate.connect(ensure_auto_upgrade_periodic_task, sender=self)
+            ensure_auto_upgrade_periodic_task()
 
         from django.db.backends.signals import connection_created