Implementing Advanced Features in Django FormWizard

Based on your requirements, you need to enhance your SessionWizardView implementation to support saving data at each step, navigation between steps, and resuming the wizard. Here's how you can implement these features:

1. Saving Data at Each Step

You've mentioned overriding process_step() to save data. Here's how to implement it:

PYTHONCopied
def process_step(self, form):
    # Get the cleaned data from the form
    form_data = self.get_form_data(form)
    
    # Get the current step
    current_step = self.steps.current
    
    # Save the data to your database
    # Example: assuming you have a UserWizardData model
    user = self.request.user  # Assuming user is authenticated
    
    # Update or create a record
    UserWizardData.objects.update_or_create(
        user=user,
        step=current_step,
        defaults={'data': form_data}
    )
    
    return super().process_step(form)

2. Preloading Previous Form Data

To preload data when users navigate back, override get_form_initial():

PYTHONCopied
def get_form_initial(self, step):
    initial = super().get_form_initial(step)
    
    # Try to get saved data for this step
    user = self.request.user
    try:
        saved_data = UserWizardData.objects.get(user=user, step=step)
        # Merge the saved data with any existing initial data
        initial.update(saved_data.data)
    except UserWizardData.DoesNotExist:
        pass
        
    return initial

3. Custom Navigation Between Steps

For custom navigation, you'll need to:

1. Override get_context_data() to provide navigation info
2. Add a custom URL parameter for navigation
3. Override get_next_step() to handle custom navigation

PYTHONCopied
def get_context_data(self, form, **kwargs):
    context = super().get_context_data(form=form, **kwargs)
    
    # Add all steps to context for navigation
    context['all_steps'] = [
        {'name': name, 'index': index, 'completed': self.get_cleaned_data_for_step(name) is not None}
        for index, name in enumerate(self.get_form_list())
    ]
    
    return context

def post(self, *args, **kwargs):
    # Check if a specific step was requested via POST
    goto_step = self.request.POST.get('goto_step', None)
    if goto_step and goto_step in self.get_form_list():
        self.storage.current_step = goto_step
        return self.render_goto_step(goto_step)
        
    return super().post(*args, **kwargs)

4. Resuming the Wizard

The SessionWizardView already stores its state in the session, but you can enhance this by:

1. Adding a unique identifier for each wizard instance
2. Storing the current state in your database

PYTHONCopied
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    # Generate or retrieve a unique wizard ID
    self.wizard_id = self.request.session.get('wizard_id', str(uuid.uuid4()))
    self.request.session['wizard_id'] = self.wizard_id

def get(self, *args, **kwargs):
    # Check if we need to resume a previous session
    if 'wizard_id' in self.request.session:
        # Try to load the wizard state from the database
        try:
            wizard_state = WizardState.objects.get(
                wizard_id=self.request.session['wizard_id'],
                user=self.request.user
            )
            # Restore the current step
            self.storage.current_step = wizard_state.current_step
        except WizardState.DoesNotExist:
            pass
    
    return super().get(*args, **kwargs)

def process_step(self, form):
    result = super().process_step(form)
    
    # Save the current state to the database
    WizardState.objects.update_or_create(
        wizard_id=self.wizard_id,
        user=self.request.user,
        defaults={'current_step': self.steps.current}
    )
    
    return result

Complete Implementation

Here's a complete implementation incorporating all the features:

PYTHONCopied
import uuid
from django.shortcuts import redirect
from formtools.wizard.views import SessionWizardView
from .forms import Step1Form, Step2Form, Step3Form
from .models import UserWizardData, WizardState

class OrangeSimulationWizardView(SessionWizardView):
    template_name = 'path/to/template.html'
    form_list = [
        ('step1', Step1Form),
        ('step2', Step2Form),
        ('step3', Step3Form),
    ]
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        if hasattr(self, 'request'):
            # Generate or retrieve a unique wizard ID
            self.wizard_id = self.request.session.get('wizard_id', str(uuid.uuid4()))
            self.request.session['wizard_id'] = self.wizard_id
    
    def get(self, *args, **kwargs):
        # Check if we need to resume a previous session
        if hasattr(self, 'request') and 'wizard_id' in self.request.session:
            # Try to load the wizard state from the database
            try:
                wizard_state = WizardState.objects.get(
                    wizard_id=self.request.session['wizard_id'],
                    user=self.request.user
                )
                # Restore the current step
                self.storage.current_step = wizard_state.current_step
            except WizardState.DoesNotExist:
                pass
        
        return super().get(*args, **kwargs)
    
    def get_form_kwargs(self, step=None):
        kwargs = super().get_form_kwargs(step)
        # Customize form kwargs if needed, based on the step
        return kwargs
    
    def get_form_initial(self, step):
        initial = super().get_form_initial(step)
        
        # Try to get saved data for this step
        if hasattr(self, 'request') and self.request.user.is_authenticated:
            try:
                saved_data = UserWizardData.objects.get(
                    user=self.request.user, 
                    step=step
                )
                # Merge the saved data with any existing initial data
                initial.update(saved_data.data)
            except UserWizardData.DoesNotExist:
                pass
            
        return initial
    
    def get_context_data(self, form, **kwargs):
        context = super().get_context_data(form=form, **kwargs)
        
        # Add all steps to context for navigation
        context['all_steps'] = [
            {
                'name': name, 
                'index': index, 
                'completed': self.get_cleaned_data_for_step(name) is not None
            }
            for index, name in enumerate(self.get_form_list())
        ]
        
        return context
    
    def post(self, *args, **kwargs):
        # Check if a specific step was requested via POST
        goto_step = self.request.POST.get('goto_step', None)
        if goto_step and goto_step in self.get_form_list():
            self.storage.current_step = goto_step
            return self.render_goto_step(goto_step)
            
        return super().post(*args, **kwargs)
    
    def process_step(self, form):
        # Get the cleaned data from the form
        form_data = form.cleaned_data
        
        # Get the current step
        current_step = self.steps.current
        
        # Save the data to your database
        if hasattr(self, 'request') and self.request.user.is_authenticated:
            # Update or create a record
            UserWizardData.objects.update_or_create(
                user=self.request.user,
                step=current_step,
                defaults={'data': form_data}
            )
            
            # Save the current state to the database
            WizardState.objects.update_or_create(
                wizard_id=self.wizard_id,
                user=self.request.user,
                defaults={'current_step': self.steps.current}
            )
        
        return super().process_step(form)
    
    def done(self, form_list, form_dict, **kwargs):
        # Access forms by their step name using form_dict
        step1_data = form_dict['step1'].cleaned_data
        step2_data = form_dict['step2'].cleaned_data
        step3_data = form_dict['step3'].cleaned_data
        
        # Process the final submission
        # For example, create a final record with all data
        
        # Clean up temporary data if needed
        if hasattr(self, 'request') and self.request.user.is_authenticated:
            # Optionally delete the temporary wizard state
            WizardState.objects.filter(
                wizard_id=self.wizard_id,
                user=self.request.user
            ).delete()
        
        return redirect('some-view-name')

Template Example

Here's how your template might look to support navigation between steps:

HTMLCopied
<form method="post" action="{% url 'your-wizard-url' %}">
    {% csrf_token %}
    {{ wizard.management_form }}
    
    <div class="wizard-navigation">
        {% for step in all_steps %}
            <button type="submit" name="goto_step" value="{{ step.name }}" 
                    {% if step.name == wizard.steps.current %}class="active"{% endif %}>
                Step {{ step.index|add:1 }}
                {% if step.completed %}✓{% endif %}
            </button>
        {% endfor %}
    </div>
    
    <div class="wizard-form">
        {{ form }}
    </div>
    
    <div class="wizard-buttons">
        {% if wizard.steps.prev %}
            <button type="submit" name="wizard_goto_step" value="{{ wizard.steps.prev }}">Previous</button>
        {% endif %}
        
        <button type="submit">{% if wizard.steps.next %}Next{% else %}Submit{% endif %}</button>
    </div>
</form>

Don't forget to create the necessary models for storing the wizard data:

PYTHONCopied
from django.db import models
from django.contrib.auth.models import User
import json

class UserWizardData(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    step = models.CharField(max_length=100)
    data = models.JSONField()
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        unique_together = ('user', 'step')

class WizardState(models.Model):
    wizard_id = models.CharField(max_length=100)
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    current_step = models.CharField(max_length=100)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        unique_together = ('wizard_id', 'user')

This implementation provides all the features you requested while maintaining the core functionality of the Django FormWizard.