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

core/admin.py

@@ -21,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
@@ -51,6 +53,7 @@ from .models import (
     Reference,
     OdooProfile,
     EmailInbox,
+    SocialProfile,
     EmailCollector,
     Package,
     PackageRelease,
@@ -73,6 +76,7 @@ from .user_data import (
 )
 from .widgets import OdooProductWidget
 from .mcp import process as mcp_process
+from .mcp.server import resolve_base_urls
 
 
 admin.site.unregister(Group)
@@ -260,6 +264,7 @@ class ReferenceAdmin(EntityModelAdmin):
     list_display = (
         "alt_text",
         "content_type",
+        "link",
         "header",
         "footer",
         "visibility",
@@ -304,6 +309,15 @@ class ReferenceAdmin(EntityModelAdmin):
     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 = [
@@ -358,6 +372,29 @@ class ReleaseManagerAdminForm(forms.ModelForm):
             "github_token": forms.Textarea(attrs={"rows": 3, "style": "width: 40em;"}),
         }
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["pypi_token"].help_text = format_html(
+            "{} <a href=\"{}\" target=\"_blank\" rel=\"noopener noreferrer\">{}</a>{}",
+            "Generate an API token from your PyPI account settings.",
+            "https://pypi.org/manage/account/token/",
+            "pypi.org/manage/account/token/",
+            (
+                " by clicking “Add API token”, optionally scoping it to the package, "
+                "and paste the full `pypi-***` value here."
+            ),
+        )
+        self.fields["github_token"].help_text = format_html(
+            "{} <a href=\"{}\" target=\"_blank\" rel=\"noopener noreferrer\">{}</a>{}",
+            "Create a personal access token at GitHub → Settings → Developer settings →",
+            "https://github.com/settings/tokens",
+            "github.com/settings/tokens",
+            (
+                " with the repository access needed for releases (repo scope for classic tokens "
+                "or an equivalent fine-grained token) and paste it here."
+            ),
+        )
+
 
 @admin.register(ReleaseManager)
 class ReleaseManagerAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin):
@@ -532,7 +569,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",
@@ -543,6 +587,7 @@ class InviteLeadAdmin(EntityModelAdmin):
         "ip_address",
         "mac_address",
         "sent_on",
+        "sent_via_outbox",
         "error",
     )
 
@@ -669,28 +714,30 @@ class OdooProfileAdminForm(forms.ModelForm):
         )
 
 
-class EmailInboxAdminForm(forms.ModelForm):
-    """Admin form for :class:`core.models.EmailInbox` with hidden password."""
-
-    password = forms.CharField(
-        widget=forms.PasswordInput(render_value=True),
-        required=False,
-        help_text="Leave blank to keep the current password.",
-    )
+class MaskedPasswordFormMixin:
+    """Mixin that hides stored passwords while allowing updates."""
 
-    class Meta:
-        model = EmailInbox
-        fields = "__all__"
+    password_sigil_fields: tuple[str, ...] = ()
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
+        field = self.fields.get("password")
+        if field is None:
+            return
+        if not isinstance(field.widget, forms.PasswordInput):
+            field.widget = forms.PasswordInput()
+        field.widget.attrs.setdefault("autocomplete", "new-password")
+        field.help_text = field.help_text or "Leave blank to keep the current password."
         if self.instance.pk:
-            self.fields["password"].initial = ""
+            field.initial = ""
             self.initial["password"] = ""
         else:
-            self.fields["password"].required = True
+            field.required = True
 
     def clean_password(self):
+        field = self.fields.get("password")
+        if field is None:
+            return self.cleaned_data.get("password")
         pwd = self.cleaned_data.get("password")
         if not pwd and self.instance.pk:
             return keep_existing("password")
@@ -698,10 +745,23 @@ class EmailInboxAdminForm(forms.ModelForm):
 
     def _post_clean(self):
         super()._post_clean()
-        _restore_sigil_values(
-            self,
-            ["username", "host", "password", "protocol"],
-        )
+        if self.password_sigil_fields:
+            _restore_sigil_values(self, self.password_sigil_fields)
+
+
+class EmailInboxAdminForm(MaskedPasswordFormMixin, forms.ModelForm):
+    """Admin form for :class:`core.models.EmailInbox` with hidden password."""
+
+    password = forms.CharField(
+        widget=forms.PasswordInput(attrs={"autocomplete": "new-password"}),
+        required=False,
+        help_text="Leave blank to keep the current password.",
+    )
+    password_sigil_fields = ("username", "host", "password", "protocol")
+
+    class Meta:
+        model = EmailInbox
+        fields = "__all__"
 
 
 class ProfileInlineFormSet(BaseInlineFormSet):
@@ -851,16 +911,33 @@ class EmailInboxInlineForm(ProfileFormMixin, EmailInboxAdminForm):
         exclude = ("user", "group")
 
 
-class EmailOutboxInlineForm(ProfileFormMixin, forms.ModelForm):
-    profile_fields = EmailOutbox.profile_fields
+class SocialProfileInlineForm(ProfileFormMixin, forms.ModelForm):
+    profile_fields = SocialProfile.profile_fields
+
+    class Meta:
+        model = SocialProfile
+        fields = ("network", "handle", "domain", "did")
+
+
+class EmailOutboxAdminForm(MaskedPasswordFormMixin, forms.ModelForm):
+    """Admin form for :class:`nodes.models.EmailOutbox` with hidden password."""
+
     password = forms.CharField(
-        widget=forms.PasswordInput(render_value=True),
+        widget=forms.PasswordInput(attrs={"autocomplete": "new-password"}),
         required=False,
         help_text="Leave blank to keep the current password.",
     )
+    password_sigil_fields = ("password", "host", "username", "from_email")
 
     class Meta:
         model = EmailOutbox
+        fields = "__all__"
+
+
+class EmailOutboxInlineForm(ProfileFormMixin, EmailOutboxAdminForm):
+    profile_fields = EmailOutbox.profile_fields
+
+    class Meta(EmailOutboxAdminForm.Meta):
         fields = (
             "password",
             "host",
@@ -869,27 +946,7 @@ class EmailOutboxInlineForm(ProfileFormMixin, forms.ModelForm):
             "use_tls",
             "use_ssl",
             "from_email",
-        )
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        if self.instance.pk:
-            self.fields["password"].initial = ""
-            self.initial["password"] = ""
-        else:
-            self.fields["password"].required = True
-
-    def clean_password(self):
-        pwd = self.cleaned_data.get("password")
-        if not pwd and self.instance.pk:
-            return keep_existing("password")
-        return pwd
-
-    def _post_clean(self):
-        super()._post_clean()
-        _restore_sigil_values(
-            self,
-            ["password", "host", "username", "from_email"],
+            "is_enabled",
         )
 
 
@@ -998,6 +1055,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": (
@@ -1056,6 +1129,7 @@ PROFILE_MODELS = (
     OdooProfile,
     EmailInbox,
     EmailOutbox,
+    SocialProfile,
     ReleaseManager,
     AssistantProfile,
 )
@@ -1202,8 +1276,68 @@ 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)
@@ -1217,10 +1351,8 @@ class OdooProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdm
     changelist_actions = ["my_profile"]
     fieldsets = (
         ("Owner", {"fields": ("user", "group")}),
-        (
-            "Configuration",
-            {"fields": ("host", "database", "username", "password")},
-        ),
+        ("Configuration", {"fields": ("host", "database")}),
+        ("Credentials", {"fields": ("username", "password")}),
         (
             "Odoo Employee",
             {"fields": ("verified_on", "odoo_uid", "name", "email")},
@@ -1310,18 +1442,10 @@ class EmailInboxAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmi
 
     fieldsets = (
         ("Owner", {"fields": ("user", "group")}),
+        ("Credentials", {"fields": ("username", "password")}),
         (
-            None,
-            {
-                "fields": (
-                    "username",
-                    "host",
-                    "port",
-                    "password",
-                    "protocol",
-                    "use_ssl",
-                )
-            },
+            "Configuration",
+            {"fields": ("host", "port", "protocol", "use_ssl")},
         ),
     )
 
@@ -1383,6 +1507,7 @@ class EmailInboxAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmi
                     subject=form.cleaned_data["subject"],
                     from_address=form.cleaned_data["from_address"],
                     body=form.cleaned_data["body"],
+                    use_regular_expressions=False,
                 )
                 context = {
                     "form": form,
@@ -1418,17 +1543,10 @@ class AssistantProfileAdmin(
     changelist_actions = ["my_profile"]
     fieldsets = (
         ("Owner", {"fields": ("user", "group")}),
+        ("Credentials", {"fields": ("user_key_hash",)}),
         (
-            None,
-            {
-                "fields": (
-                    "scopes",
-                    "is_active",
-                    "user_key_hash",
-                    "created_at",
-                    "last_used_at",
-                )
-            },
+            "Configuration",
+            {"fields": ("scopes", "is_active", "created_at", "last_used_at")},
         ),
     )
 
@@ -1519,14 +1637,19 @@ class AssistantProfileAdmin(
         config = dict(getattr(settings, "MCP_SIGIL_SERVER", {}))
         host = config.get("host") or "127.0.0.1"
         port = config.get("port", 8800)
+        base_url, issuer_url = resolve_base_urls(config)
         if isinstance(response, dict):
             response.setdefault("mcp_server_host", host)
             response.setdefault("mcp_server_port", port)
+            response.setdefault("mcp_server_base_url", base_url)
+            response.setdefault("mcp_server_issuer_url", issuer_url)
         else:
             context_data = getattr(response, "context_data", None)
             if context_data is not None:
                 context_data.setdefault("mcp_server_host", host)
                 context_data.setdefault("mcp_server_port", port)
+                context_data.setdefault("mcp_server_base_url", base_url)
+                context_data.setdefault("mcp_server_issuer_url", issuer_url)
         return response
 
     def start_server(self, request):
@@ -1814,7 +1937,7 @@ class ProductFetchWizardForm(forms.Form):
 @admin.register(Product)
 class ProductAdmin(EntityModelAdmin):
     form = ProductAdminForm
-    actions = ["fetch_odoo_product"]
+    actions = ["fetch_odoo_product", "register_from_odoo"]
 
     def _odoo_profile_admin(self):
         return self.admin_site._registry.get(OdooProfile)
@@ -1824,7 +1947,7 @@ class ProductAdmin(EntityModelAdmin):
         return profile.execute(
             "product.product",
             "search_read",
-            domain,
+            [domain],
             {
                 "fields": [
                     "name",
@@ -1964,6 +2087,169 @@ class ProductAdmin(EntityModelAdmin):
         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 = [
+            path(
+                "register-from-odoo/",
+                self.admin_site.admin_view(self.register_from_odoo_view),
+                name=f"{self.opts.app_label}_{self.opts.model_name}_register_from_odoo",
+            )
+        ]
+        return custom + urls
+
+    @admin.action(description="Register from Odoo")
+    def register_from_odoo(self, request, queryset=None):  # pragma: no cover - simple redirect
+        return HttpResponseRedirect(
+            reverse(
+                f"admin:{self.opts.app_label}_{self.opts.model_name}_register_from_odoo"
+            )
+        )
+
+    def _build_register_context(self, request):
+        opts = self.model._meta
+        context = self.admin_site.each_context(request)
+        context.update(
+            {
+                "opts": opts,
+                "title": _("Register from Odoo"),
+                "has_credentials": False,
+                "profile_url": None,
+                "products": [],
+                "selected_product_id": request.POST.get("product_id", ""),
+            }
+        )
+
+        profile_admin = self._odoo_profile_admin()
+        if profile_admin is not None:
+            context["profile_url"] = profile_admin.get_my_profile_url(request)
+
+        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."
+            )
+            return context, None
+
+        try:
+            products = profile.execute(
+                "product.product",
+                "search_read",
+                [[]],
+                {
+                    "fields": [
+                        "name",
+                        "description_sale",
+                        "list_price",
+                        "standard_price",
+                    ],
+                    "limit": 0,
+                },
+            )
+        except Exception:
+            context["error"] = _("Unable to fetch products from Odoo.")
+            return context, []
+
+        context["has_credentials"] = True
+        simplified = []
+        for product in products:
+            simplified.append(
+                {
+                    "id": product.get("id"),
+                    "name": product.get("name", ""),
+                    "description_sale": product.get("description_sale", ""),
+                    "list_price": product.get("list_price"),
+                    "standard_price": product.get("standard_price"),
+                }
+            )
+        context["products"] = simplified
+        return context, simplified
+
+    def register_from_odoo_view(self, request):
+        context, products = self._build_register_context(request)
+        if products is None:
+            return TemplateResponse(
+                request, "admin/core/product/register_from_odoo.html", context
+            )
+
+        if request.method == "POST" and context.get("has_credentials"):
+            if not self.has_add_permission(request):
+                context["form_error"] = _(
+                    "You do not have permission to add products."
+                )
+            else:
+                product_id = request.POST.get("product_id")
+                if not product_id:
+                    context["form_error"] = _("Select a product to register.")
+                else:
+                    try:
+                        odoo_id = int(product_id)
+                    except (TypeError, ValueError):
+                        context["form_error"] = _("Invalid product selection.")
+                    else:
+                        match = next(
+                            (item for item in products if item.get("id") == odoo_id),
+                            None,
+                        )
+                        if not match:
+                            context["form_error"] = _(
+                                "The selected product was not found. Reload the page and try 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=30,
+                                odoo_product={
+                                    "id": odoo_id,
+                                    "name": match.get("name", ""),
+                                },
+                            )
+                            self.log_addition(
+                                request, product, "Registered 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],
+                                )
+                            )
+
+        return TemplateResponse(
+            request, "admin/core/product/register_from_odoo.html", context
+        )
+
 
 class RFIDResource(resources.ModelResource):
     reference = fields.Field(
@@ -2265,6 +2551,7 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
         "package_link",
         "is_current",
         "pypi_url",
+        "release_on",
         "revision_short",
         "published_status",
     )
@@ -2272,7 +2559,7 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
     actions = ["publish_release", "validate_releases"]
     change_actions = ["publish_release_action"]
     changelist_actions = ["refresh_from_pypi", "prepare_next_release"]
-    readonly_fields = ("pypi_url", "is_current", "revision")
+    readonly_fields = ("pypi_url", "release_on", "is_current", "revision")
     fields = (
         "package",
         "release_manager",
@@ -2280,6 +2567,7 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
         "revision",
         "is_current",
         "pypi_url",
+        "release_on",
     )
 
     @admin.display(description="package", ordering="package")
@@ -2307,32 +2595,84 @@ 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: