[Django]-Workflow frameworks for Django

Are there other options out there worth considering that might be better or better supported?

Yes.

Python.

You don’t need a workflow product to automate the state transitions, permissioning, and perhaps some extras like audit logging and notifications.

There’s a reason why there aren’t many projects doing this.

• The State design pattern is pretty easy to implement.

• The Authorization rules (“permissioning”) are already a first-class
  part of Django.

• Logging is already a first-class part of Python (and has been
  added to Django). Using this for audit logging is either an audit
  table or another logger (or both).

• The message framework (“notifications”) is already part of Django.

What more do you need? You already have it all.

Using class definitions for the State design pattern, and decorators for authorization and logging works out so well that you don’t need anything above and beyond what you already have.

Read this related question: Implementing a "rules engine" in Python

A package written by an associate of mine, django-fsm, seems to work–it’s both fairly lightweight and sufficiently featureful to be useful.

It’s funny because I would have agreed with S.Lott about just using Python as is for a rule engine. I have a COMPLETELY different perspective now having done it.

If you want a full rule engine, it needs a quite a few moving parts. We built a full Python/Django rules engine and you would be surprised what needs to be built in to get a great rule engine up and running. I will explain further, but first the website is http://nebrios.com.

A rule engine should atleast have:

• Acess Control Lists – Do you want everyone seeing everything?
• Key/Value pair API – KVP’s store the state, and all the rules react to changed states.
• Debug mode – Being able to see every changed state, what changed it and why. Paramount.
• Interaction through web forms and email – Being able to quickly script a web form is a huge plus, along with parsing incoming emails consistently.
• Process ID’s – These track a “thread” of business value. Otherwise processes would be continually overlapping.
• Sooo much more!

So try out Nebri, or the others I list below to see if they meet your needs.

Here’s the debug mode

An auto generated form

A sample workflow rule:

class task_sender(NebriOS):
# send a task to the person it got assigned to
listens_to = ['created_date']

def check(self):
    return (self.created_date is not None) and (self.creator_status != "complete") and (self.assigned is not None)

def action(self):
    send_email (self.assigned,"""
        The ""{{task_title}}"" task was just sent your way!

        Once you finish, send this email back to log the following in the system:

        i_am_finished := true

        It will get assigned back to the task creator to look over.

        Thank you!! - The Nebbs
        """, subject="""{{task_title}}""")

So, no, it’s not simple to build a rules based, event based workflow engine in Python alone. We have been at it over a year! I would recommend using tools like

• http://nebrios.com
• http://pyke.sourceforge.net (It’s Python also!)
• http://decisions.com
• http://clipsrules.sourceforge.net

I can add one more library which supports on the fly changes on workflow components unlike its equivalents.

Look at django-river

It is now with a pretty admin called River Admin

ActivFlow: a generic, light-weight and extensible workflow engine for agile development and automation of complex Business Process operations.

You can have an entire workflow modeled in no time!

Step 1: Workflow App Registration

WORKFLOW_APPS = ['leave_request']

Step 2: Activity Configuration

from activflow.core.models import AbstractActivity, AbstractInitialActivity
from activflow.leave_request.validators import validate_initial_cap

class RequestInitiation(AbstractInitialActivity):
    """Leave request details"""
    employee_name = CharField(
        "Employee", max_length=200, validators=[validate_initial_cap])
    from = DateField("From Date")
    to = DateField("To Date")
    reason = TextField("Purpose of Leave", blank=True)

    def clean(self):
        """Custom validation logic should go here"""
        pass

class ManagementApproval(AbstractActivity):
    """Management approval"""
    approval_status = CharField(verbose_name="Status", max_length=3, choices=(
        ('APP', 'Approved'), ('REJ', 'Rejected')))
    remarks = TextField("Remarks")

    def clean(self):
        """Custom validation logic should go here"""
        pass

Step 3: Flow Definition

FLOW = {
'initiate_request': {
    'name': 'Leave Request Initiation',
    'model': RequestInitiation,
    'role': 'Submitter',
    'transitions': {
        'management_approval': validate_request,
    }
},
'management_approval': {
    'name': 'Management Approval',
    'model': ManagementApproval,
    'role': 'Approver',
    'transitions': None
    }
}

Step 4: Business Rules

def validate_request(self):
    return self.reason == 'Emergency'

I migrate the django-goflow from django 1.X -python 2.X to fit for django 2.X – python 3.x, the project is at django2-goflow