CODEWITHSUNDEEP
pythondjangodjango-forms
Jordan Reiter
Jordan Reiter

Reputation: 21002

Change a django form class before it is instantiated

I'm wondering if it's possible to alter or change a form class before it's instantiated.

As a concrete example, I have a payment form which needs to be modified based on the payment system being used.

Ideally I'd rather not create different form classes and then choose different ones based on the payment system; instead the payment system object will "tell" the form class what changes it need to make -- for example, making certain fields optional or instructing them to use different widgets.

Is this possible? The alternative is to pass an object representing the payment system into the form, and then having it modify the form after instantiation, but that just seems clumsy somehow to have it run in the form class rather than the view. I feel like the Django "view" is closer to a controller, and it seems like this is where something like this should happen. I also feel like modifying it'd be better to modify the form_class object rather than the form instance; I'm not even sure if when you add fields after the fact like this it will handle validation and form fill-in correctly. Will it?

Anywhere, here's some sample code of how it would work passing the payment object into a form instantiation call:

payment_system.py:

class ExamplePaymentSystem(BasePaymentSystem):
    def modify_form(self, form):
        for fld in self.optional_fields:
            form.fields[fld].required = False
        …etc…

forms.py:

class ModifiablePaymentForm(forms.ModelForm):
    def __init__(self, *args, **kwargs):
        self.payment_system = kwargs.pop("payment_system", None)
        super(ModifiablePaymentSystem, self).__init__(*args, **kwargs)
        self.payment_system.modify_form(self)

Upvotes: 0

Views: 865

Answers (1)

jb.
jb.

Reputation: 23955

You should not modify global static data (classes defined at module scope are static), because if you run your code in many threads per process (which is often done) one thread may modify form class used by the other threads.

If you your payment systems are static (you do not add new on the fly, while server is running) I'd define one form per payment system.

If not, you can always, define new form types on the fly like that:

 def get_form_type(payment_system): 
    class DynamicForm(BasePaymentForm): 
        ... add change fields etc... 
    return DynamicForm

or modify instances like that:

class PaymentForm(BasePaymentForm): 

     def __init__(self, ..., payment_system):
         self.fields['foo'].required = False # <--- I'm writing code 
         #from the memory, so possibly you'll need t edit it 
         #but this is doable and easy to do.

How to remove field in forms (per OP request).

When you subclass:

This is hard and I think you'll need to browse through form internals and modify them by hand after subclass creation. This is a wild guess...

 def get_form_type(payment_system): 
    class DynamicForm(BasePaymentForm): 
        ... add change fields etc... 
    del DynamicForm.base_fields['foo']
    return DynamicForm

When you modify instance: I'm not 100% sure, but I peeked into django source code (unfortunately these details are not in docs). But i guess that you should:

 class PaymentForm(BasePaymentForm): 
     def __init__(self, ..., payment_system):
         del self.fields['foo']

The fields are a dict (or I guess -- OrderedDict for that matter) and to delete field you need to remove whole key-vaule mapping.

Upvotes: 3

Related Questions