Do we need to Integrate an admin solution

[pfouque]

Multiple libraries were created to handle django-fsm from the admin (but none of them have been updated in the last 3 years)

• django-fsm-admin: The main one
• django-fsm-admin-lite: Pure backend solution created by @etchegom
• django-fsm-admin2: Was created to handle transitions' arguments

To me, it would make sense to embed such a solution in the main project (if it doesn't increase too much the maintenance duty)

What do you think?

[pfouque]

After a first investigation, I'd like to mix these 2 solutions as they are light and have interesting features:

• django-fsm-admin-lite is really light and works with a secured POST request.
• django-fsm-admin2: the ability to declare an intermediate form is a real game changer.

On top of that, it would be nice to add fsm-log support

NB: They are both licensed as MIT, but I'll try to contact the maintainers

[peterfarrell]

@pfouque Please let me know what I can do to assist. I'd like to see your idea of incorporating the best of those packages into an integrated admin module for this project.

[pfouque]

Hi @peterfarrell,

This one is almost complete: #49

It recently reached the feature set of django-fsm-admin (but with an alternative solution, lighter).
It's mainly waiting for feedback, especially from people migrating from django-fsm-log (I'm still wondering if the best strategy is to override the template, or declare a read_only property...)

Feel free to test and share your experience!

Thanks

NB: This one was much easier, especially on the scope to target and I already started the next step (unpublished yet) to provide the custom form integration (inspired from django-fsm-admin2).

[madisvain]

It would be so awesome to have this feature in django-fsm-2 👍

If there is anything I can do help this move forward then I'd love to help. One addition that I do recommend is that the state changes could also be enabled from the list view as batch actions.

I have built myself a admin mixin

from django.contrib import messages
from django.utils.translation import gettext_lazy as _
from django_fsm import can_proceed


class FSMAdminMixin:
    """
    Mixin to provide FSM state-changing admin actions.

    Usage:
        class MyModelAdmin(FSMAdminMixin, admin.ModelAdmin):
            fsm_field = 'state'  # Name of the FSM field
            fsm_transitions = [
                ('to_confirmed', _("Mark as confirmed")),
                ('to_voided', _("Mark as voided")),
                ('to_draft', _("Mark as draft")),
            ]
    """

    fsm_field = "state"
    fsm_transitions = []

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._setup_fsm_actions()

    def _setup_fsm_actions(self):
        """Set up FSM actions dynamically."""
        # Ensure actions is a list
        if not hasattr(self, "actions"):
            self.actions = []
        elif self.actions is None:
            self.actions = []
        else:
            self.actions = list(self.actions)

        # Generate action methods and add them to actions
        for transition_method, description in self.fsm_transitions:
            action_name = f"fsm_{transition_method}"
            if not hasattr(self, action_name):
                # Create the action method dynamically
                action_method = self._create_fsm_action(transition_method, description)
                setattr(self, action_name, action_method)

            # Add to actions list if not already there
            if action_name not in self.actions:
                self.actions.append(action_name)

    def _create_fsm_action(self, transition_method, description):
        """Create a dynamic FSM action method."""

        def fsm_action(self, request, queryset):
            success_count = 0
            failure_count = 0

            for obj in queryset:
                # Get the transition method from the object
                if hasattr(obj, transition_method):
                    transition_func = getattr(obj, transition_method)

                    # Check if transition is valid
                    if can_proceed(transition_func):
                        try:
                            transition_func()
                            obj.save()
                            success_count += 1
                        except Exception:
                            failure_count += 1
                    else:
                        failure_count += 1
                else:
                    failure_count += 1

            # Show success message
            if success_count:
                self.message_user(
                    request,
                    _("Successfully updated {count} {model}(s).").format(
                        count=success_count, model=self.model._meta.verbose_name
                    ),
                    messages.SUCCESS,
                )

            # Show failure message
            if failure_count:
                self.message_user(
                    request,
                    _(
                        "Failed to update {count} {model}(s) (invalid state transition or error)."
                    ).format(count=failure_count, model=self.model._meta.verbose_name),
                    messages.ERROR,
                )

        # Set the description attribute for Django admin (older style)
        fsm_action.short_description = description
        return fsm_action

    def get_actions(self, request):
        """Override to ensure FSM actions are included."""
        actions = super().get_actions(request)

        # Ensure our FSM actions are included
        for transition_method, description in self.fsm_transitions:
            action_name = f"fsm_{transition_method}"
            if hasattr(self, action_name):
                action_method = getattr(self, action_name)
                actions[action_name] = (action_method, action_name, description)

        return actions

And use it in the admin like

from django.contrib import admin
from django.utils.translation import gettext_lazy as _

from payroll.utils.admin import FSMAdminMixin

from .models import Payment


@admin.register(Payment)
class PaymentAdmin(FSMAdminMixin, admin.ModelAdmin):
    list_display = [
        "employee",
        "payment_type",
        "state",
        "payment_reference",
        "net_amount",
        "payment_date",
        "payment_description",
        "created_at",
        "updated_at",
    ]
    readonly_fields = ["id", "created_at", "updated_at"]
    list_filter = ["payment_date", "state", "created_at", "updated_at"]
    date_hierarchy = "created_at"
    actions = []  # Initialize actions list for FSM mixin to extend
    
    # FSM configuration
    fsm_field = 'state'
    fsm_transitions = [
        ('to_paid', _("Mark selected payments as paid")),
        ('to_voided', _("Mark selected payments as voided")),
        ('to_draft', _("Mark selected payments as draft")),
    ]

[pfouque]

Thanks @madisvain,
It's an Interesting use case, but I'm not sure the default admin should provide it:

• The list of available transitions is dynamic and will depend on the state of the objects, it can be even more dynamic if conditions are declared.
• In the end It's not so related to django-fsm, it's more a smart generator of admin actions. But I can see related methods in Add AdminMixin: Form management #59 that could make it easier to implement (like applying transitions)

I'm almost done with #59, I need to complete the QA and probably fix a couple of bugs,
If you're willing to give it a try, feedback will be greatly appreciated! 😉