arthexis 0.1.9__py3-none-any.whl → 0.1.11__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
@@ -20,6 +21,8 @@ from import_export.admin import ImportExportModelAdmin
 from import_export.widgets import ForeignKeyWidget
 from django.contrib.auth.models import Group
 from django.templatetags.static import static
+from django.utils import timezone
+from django.utils.dateparse import parse_datetime
 from django.utils.html import format_html
 from django.utils.translation import gettext_lazy as _
 from django.forms.models import BaseInlineFormSet
@@ -50,6 +53,7 @@ from .models import (
     Reference,
     OdooProfile,
     EmailInbox,
+    SocialProfile,
     EmailCollector,
     Package,
     PackageRelease,
@@ -61,7 +65,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 +173,98 @@ 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",
+        "link",
+        "header",
         "footer",
         "visibility",
         "author",
@@ -182,6 +281,7 @@ class ReferenceAdmin(EntityModelAdmin):
         "features",
         "sites",
         "include_in_footer",
+        "show_in_header",
         "footer_visibility",
         "transaction_uuid",
         "author",
@@ -200,10 +300,23 @@ 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()
 
+    @admin.display(description="LINK")
+    def link(self, obj):
+        if obj.value:
+            return format_html(
+                '<a href="{}" target="_blank" rel="noopener noreferrer">open</a>',
+                obj.value,
+            )
+        return ""
+
     def get_urls(self):
         urls = super().get_urls()
         custom = [
@@ -260,11 +373,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 +439,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 +449,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 +505,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)
 
@@ -442,7 +545,14 @@ class SecurityGroupAdmin(DjangoGroupAdmin):
 
 
 class InviteLeadAdmin(EntityModelAdmin):
-    list_display = ("email", "mac_address", "created_on", "sent_on", "short_error")
+    list_display = (
+        "email",
+        "mac_address",
+        "created_on",
+        "sent_on",
+        "sent_via_outbox",
+        "short_error",
+    )
     search_fields = ("email", "comment")
     readonly_fields = (
         "created_on",
@@ -453,6 +563,7 @@ class InviteLeadAdmin(EntityModelAdmin):
         "ip_address",
         "mac_address",
         "sent_on",
+        "sent_via_outbox",
         "error",
     )
 
@@ -617,6 +728,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:
@@ -750,6 +872,14 @@ class EmailInboxInlineForm(ProfileFormMixin, EmailInboxAdminForm):
         exclude = ("user", "group")
 
 
+class SocialProfileInlineForm(ProfileFormMixin, forms.ModelForm):
+    profile_fields = SocialProfile.profile_fields
+
+    class Meta:
+        model = SocialProfile
+        fields = ("network", "handle", "domain", "did")
+
+
 class EmailOutboxInlineForm(ProfileFormMixin, forms.ModelForm):
     profile_fields = EmailOutbox.profile_fields
     password = forms.CharField(
@@ -768,6 +898,7 @@ class EmailOutboxInlineForm(ProfileFormMixin, forms.ModelForm):
             "use_tls",
             "use_ssl",
             "from_email",
+            "is_enabled",
         )
 
     def __init__(self, *args, **kwargs):
@@ -897,6 +1028,22 @@ PROFILE_INLINE_CONFIG = {
             "from_email",
         ),
     },
+    SocialProfile: {
+        "form": SocialProfileInlineForm,
+        "fieldsets": (
+            (
+                _("Configuration: Bluesky"),
+                {
+                    "fields": ("network", "handle", "domain", "did"),
+                    "description": _(
+                        "1. Set your Bluesky handle to the domain managed by Arthexis. "
+                        "2. Publish a _atproto TXT record or /.well-known/atproto-did file pointing to the DID below. "
+                        "3. Save once Bluesky confirms the domain matches the DID."
+                    ),
+                },
+            ),
+        ),
+    },
     ReleaseManager: {
         "form": ReleaseManagerInlineForm,
         "fields": (
@@ -955,6 +1102,7 @@ PROFILE_MODELS = (
     OdooProfile,
     EmailInbox,
     EmailOutbox,
+    SocialProfile,
     ReleaseManager,
     AssistantProfile,
 )
@@ -974,21 +1122,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 +1223,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
@@ -1042,21 +1249,85 @@ class EmailCollectorInline(admin.TabularInline):
 
 
 class EmailCollectorAdmin(EntityModelAdmin):
-    list_display = ("inbox", "subject", "sender", "body", "fragment")
-    search_fields = ("subject", "sender", "body", "fragment")
+    list_display = ("name", "inbox", "subject", "sender", "body", "fragment")
+    search_fields = ("name", "subject", "sender", "body", "fragment")
+    actions = ["preview_messages"]
+
+    @admin.action(description=_("Preview matches"))
+    def preview_messages(self, request, queryset):
+        results = []
+        for collector in queryset.select_related("inbox"):
+            try:
+                messages = collector.search_messages(limit=5)
+                error = None
+            except ValidationError as exc:
+                messages = []
+                error = str(exc)
+            except Exception as exc:  # pragma: no cover - admin feedback
+                messages = []
+                error = str(exc)
+            results.append(
+                {
+                    "collector": collector,
+                    "messages": messages,
+                    "error": error,
+                }
+            )
+        context = {
+            "title": _("Preview Email Collectors"),
+            "results": results,
+            "opts": self.model._meta,
+            "queryset": queryset,
+        }
+        return TemplateResponse(
+            request, "admin/core/emailcollector/preview.html", context
+        )
+
+
+@admin.register(SocialProfile)
+class SocialProfileAdmin(
+    ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin
+):
+    list_display = ("owner", "network", "handle", "domain")
+    list_filter = ("network",)
+    search_fields = ("handle", "domain", "did")
+    changelist_actions = ["my_profile"]
+    change_actions = ["my_profile_action"]
+    fieldsets = (
+        (_("Owner"), {"fields": ("user", "group")}),
+        (
+            _("Configuration: Bluesky"),
+            {
+                "fields": ("network", "handle", "domain", "did"),
+                "description": _(
+                    "Link Arthexis to Bluesky by using a verified domain handle. "
+                    "Publish a _atproto TXT record or /.well-known/atproto-did file "
+                    "that returns the DID stored here before saving."
+                ),
+            },
+        ),
+    )
+
+    @admin.display(description=_("Owner"))
+    def owner(self, obj):
+        return obj.owner_display()
 
 
 @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 +1359,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 +1375,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]
 
@@ -1221,6 +1490,7 @@ class EmailInboxAdmin(SaveBeforeChangeAction, EntityModelAdmin):
                     subject=form.cleaned_data["subject"],
                     from_address=form.cleaned_data["from_address"],
                     body=form.cleaned_data["body"],
+                    use_regular_expressions=False,
                 )
                 context = {
                     "form": form,
@@ -1244,12 +1514,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 +1680,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 +1885,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 +2210,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 +2254,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",
@@ -1909,14 +2373,15 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
         "package_link",
         "is_current",
         "pypi_url",
+        "release_on",
         "revision_short",
         "published_status",
     )
     list_display_links = ("version",)
     actions = ["publish_release", "validate_releases"]
     change_actions = ["publish_release_action"]
-    changelist_actions = ["refresh_from_pypi"]
-    readonly_fields = ("pypi_url", "is_current", "revision")
+    changelist_actions = ["refresh_from_pypi", "prepare_next_release"]
+    readonly_fields = ("pypi_url", "release_on", "is_current", "revision")
     fields = (
         "package",
         "release_manager",
@@ -1924,6 +2389,7 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
         "revision",
         "is_current",
         "pypi_url",
+        "release_on",
     )
 
     @admin.display(description="package", ordering="package")
@@ -1951,32 +2417,94 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
             return
         releases = resp.json().get("releases", {})
         created = 0
-        for version in releases:
-            exists = PackageRelease.all_objects.filter(
+        updated = 0
+        restored = 0
+
+        for version, files in releases.items():
+            release_on = self._release_on_from_files(files)
+            release = PackageRelease.all_objects.filter(
                 package=package, version=version
-            ).exists()
-            if not exists:
-                PackageRelease.objects.create(
-                    package=package,
-                    release_manager=package.release_manager,
-                    version=version,
-                    revision="",
-                    pypi_url=f"https://pypi.org/project/{package.name}/{version}/",
-                )
-                created += 1
-        if created:
-            PackageRelease.dump_fixture()
-            self.message_user(
-                request,
-                f"Created {created} release{'s' if created != 1 else ''} from PyPI",
-                messages.SUCCESS,
+            ).first()
+            if release:
+                update_fields = []
+                if release.is_deleted:
+                    release.is_deleted = False
+                    update_fields.append("is_deleted")
+                    restored += 1
+                if not release.pypi_url:
+                    release.pypi_url = (
+                        f"https://pypi.org/project/{package.name}/{version}/"
+                    )
+                    update_fields.append("pypi_url")
+                if release_on and release.release_on != release_on:
+                    release.release_on = release_on
+                    update_fields.append("release_on")
+                    updated += 1
+                if update_fields:
+                    release.save(update_fields=update_fields)
+                continue
+            PackageRelease.objects.create(
+                package=package,
+                release_manager=package.release_manager,
+                version=version,
+                revision="",
+                pypi_url=f"https://pypi.org/project/{package.name}/{version}/",
+                release_on=release_on,
             )
+            created += 1
+
+        if created or updated or restored:
+            PackageRelease.dump_fixture()
+            message_parts = []
+            if created:
+                message_parts.append(
+                    f"Created {created} release{'s' if created != 1 else ''} from PyPI"
+                )
+            if updated:
+                message_parts.append(
+                    f"Updated release date for {updated} release"
+                    f"{'s' if updated != 1 else ''}"
+                )
+            if restored:
+                message_parts.append(
+                    f"Restored {restored} release{'s' if restored != 1 else ''}"
+                )
+            self.message_user(request, "; ".join(message_parts), messages.SUCCESS)
         else:
             self.message_user(request, "No new releases found", messages.INFO)
 
     refresh_from_pypi.label = "Refresh from PyPI"
     refresh_from_pypi.short_description = "Refresh from PyPI"
 
+    @staticmethod
+    def _release_on_from_files(files):
+        if not files:
+            return None
+        candidates = []
+        for item in files:
+            stamp = item.get("upload_time_iso_8601") or item.get("upload_time")
+            if not stamp:
+                continue
+            when = parse_datetime(stamp)
+            if when is None:
+                continue
+            if timezone.is_naive(when):
+                when = timezone.make_aware(when, datetime.timezone.utc)
+            candidates.append(when.astimezone(datetime.timezone.utc))
+        if not candidates:
+            return None
+        return min(candidates)
+
+    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()