| """ |
| Helper functions for creating Form classes from Django models |
| and database field objects. |
| """ |
| |
| from django.utils.translation import gettext |
| from util import ValidationError |
| from forms import BaseForm, DeclarativeFieldsMetaclass, SortedDictFromList |
| from fields import Field, ChoiceField |
| from widgets import Select, SelectMultiple, MultipleHiddenInput |
| |
| __all__ = ('save_instance', 'form_for_model', 'form_for_instance', 'form_for_fields', |
| 'ModelChoiceField', 'ModelMultipleChoiceField') |
| |
| def model_save(self, commit=True): |
| """ |
| Creates and returns model instance according to self.clean_data. |
| |
| This method is created for any form_for_model Form. |
| """ |
| if self.errors: |
| raise ValueError("The %s could not be created because the data didn't validate." % self._model._meta.object_name) |
| return save_instance(self, self._model(), commit) |
| |
| def save_instance(form, instance, commit=True): |
| """ |
| Saves bound Form ``form``'s clean_data into model instance ``instance``. |
| |
| Assumes ``form`` has a field for every non-AutoField database field in |
| ``instance``. If commit=True, then the changes to ``instance`` will be |
| saved to the database. Returns ``instance``. |
| """ |
| from django.db import models |
| opts = instance.__class__._meta |
| if form.errors: |
| raise ValueError("The %s could not be changed because the data didn't validate." % opts.object_name) |
| clean_data = form.clean_data |
| for f in opts.fields: |
| if not f.editable or isinstance(f, models.AutoField): |
| continue |
| setattr(instance, f.name, clean_data[f.name]) |
| if commit: |
| instance.save() |
| for f in opts.many_to_many: |
| setattr(instance, f.attname, clean_data[f.name]) |
| # GOTCHA: If many-to-many data is given and commit=False, the many-to-many |
| # data will be lost. This happens because a many-to-many options cannot be |
| # set on an object until after it's saved. Maybe we should raise an |
| # exception in that case. |
| return instance |
| |
| def make_instance_save(instance): |
| "Returns the save() method for a form_for_instance Form." |
| def save(self, commit=True): |
| return save_instance(self, instance, commit) |
| return save |
| |
| def form_for_model(model, form=BaseForm, formfield_callback=lambda f: f.formfield()): |
| """ |
| Returns a Form class for the given Django model class. |
| |
| Provide ``form`` if you want to use a custom BaseForm subclass. |
| |
| Provide ``formfield_callback`` if you want to define different logic for |
| determining the formfield for a given database field. It's a callable that |
| takes a database Field instance and returns a form Field instance. |
| """ |
| opts = model._meta |
| field_list = [] |
| for f in opts.fields + opts.many_to_many: |
| if not f.editable: |
| continue |
| formfield = formfield_callback(f) |
| if formfield: |
| field_list.append((f.name, formfield)) |
| fields = SortedDictFromList(field_list) |
| return type(opts.object_name + 'Form', (form,), {'base_fields': fields, '_model': model, 'save': model_save}) |
| |
| def form_for_instance(instance, form=BaseForm, formfield_callback=lambda f, **kwargs: f.formfield(**kwargs)): |
| """ |
| Returns a Form class for the given Django model instance. |
| |
| Provide ``form`` if you want to use a custom BaseForm subclass. |
| |
| Provide ``formfield_callback`` if you want to define different logic for |
| determining the formfield for a given database field. It's a callable that |
| takes a database Field instance, plus **kwargs, and returns a form Field |
| instance with the given kwargs (i.e. 'initial'). |
| """ |
| model = instance.__class__ |
| opts = model._meta |
| field_list = [] |
| for f in opts.fields + opts.many_to_many: |
| if not f.editable: |
| continue |
| current_value = f.value_from_object(instance) |
| formfield = formfield_callback(f, initial=current_value) |
| if formfield: |
| field_list.append((f.name, formfield)) |
| fields = SortedDictFromList(field_list) |
| return type(opts.object_name + 'InstanceForm', (form,), |
| {'base_fields': fields, '_model': model, 'save': make_instance_save(instance)}) |
| |
| def form_for_fields(field_list): |
| "Returns a Form class for the given list of Django database field instances." |
| fields = SortedDictFromList([(f.name, f.formfield()) for f in field_list if f.editable]) |
| return type('FormForFields', (BaseForm,), {'base_fields': fields}) |
| |
| class QuerySetIterator(object): |
| def __init__(self, queryset, empty_label, cache_choices): |
| self.queryset, self.empty_label, self.cache_choices = queryset, empty_label, cache_choices |
| |
| def __iter__(self): |
| if self.empty_label is not None: |
| yield (u"", self.empty_label) |
| for obj in self.queryset: |
| yield (obj._get_pk_val(), str(obj)) |
| # Clear the QuerySet cache if required. |
| if not self.cache_choices: |
| self.queryset._result_cache = None |
| |
| class ModelChoiceField(ChoiceField): |
| "A ChoiceField whose choices are a model QuerySet." |
| # This class is a subclass of ChoiceField for purity, but it doesn't |
| # actually use any of ChoiceField's implementation. |
| def __init__(self, queryset, empty_label=u"---------", cache_choices=False, |
| required=True, widget=Select, label=None, initial=None, help_text=None): |
| self.queryset = queryset |
| self.empty_label = empty_label |
| self.cache_choices = cache_choices |
| # Call Field instead of ChoiceField __init__() because we don't need |
| # ChoiceField.__init__(). |
| Field.__init__(self, required, widget, label, initial, help_text) |
| self.widget.choices = self.choices |
| |
| def _get_choices(self): |
| # If self._choices is set, then somebody must have manually set |
| # the property self.choices. In this case, just return self._choices. |
| if hasattr(self, '_choices'): |
| return self._choices |
| # Otherwise, execute the QuerySet in self.queryset to determine the |
| # choices dynamically. Return a fresh QuerySetIterator that has not |
| # been consumed. Note that we're instantiating a new QuerySetIterator |
| # *each* time _get_choices() is called (and, thus, each time |
| # self.choices is accessed) so that we can ensure the QuerySet has not |
| # been consumed. |
| return QuerySetIterator(self.queryset, self.empty_label, self.cache_choices) |
| |
| def _set_choices(self, value): |
| # This method is copied from ChoiceField._set_choices(). It's necessary |
| # because property() doesn't allow a subclass to overwrite only |
| # _get_choices without implementing _set_choices. |
| self._choices = self.widget.choices = list(value) |
| |
| choices = property(_get_choices, _set_choices) |
| |
| def clean(self, value): |
| Field.clean(self, value) |
| if value in ('', None): |
| return None |
| try: |
| value = self.queryset.model._default_manager.get(pk=value) |
| except self.queryset.model.DoesNotExist: |
| raise ValidationError(gettext(u'Select a valid choice. That choice is not one of the available choices.')) |
| return value |
| |
| class ModelMultipleChoiceField(ModelChoiceField): |
| "A MultipleChoiceField whose choices are a model QuerySet." |
| hidden_widget = MultipleHiddenInput |
| def __init__(self, queryset, cache_choices=False, required=True, |
| widget=SelectMultiple, label=None, initial=None, help_text=None): |
| super(ModelMultipleChoiceField, self).__init__(queryset, None, cache_choices, |
| required, widget, label, initial, help_text) |
| |
| def clean(self, value): |
| if self.required and not value: |
| raise ValidationError(gettext(u'This field is required.')) |
| elif not self.required and not value: |
| return [] |
| if not isinstance(value, (list, tuple)): |
| raise ValidationError(gettext(u'Enter a list of values.')) |
| final_values = [] |
| for val in value: |
| try: |
| obj = self.queryset.model._default_manager.get(pk=val) |
| except self.queryset.model.DoesNotExist: |
| raise ValidationError(gettext(u'Select a valid choice. %s is not one of the available choices.') % val) |
| else: |
| final_values.append(obj) |
| return final_values |
