root/trunk/newforms_extra/models.py

"""
Helper functions for creating Form classes from Django models
and database field objects.

Enhanced form_for_instance fills in missing fields of the form
object's data from the original model instance.  See 'Changed from
stock newforms' in docstrings and comments.  Implemented by akaihola
2007-02-08.
"""

try:
    from django import newforms as forms
except ImportError:
    from django import forms

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)
    try:
        # Django newer than May 17, 2007
        clean_data = form.cleaned_data
    except AttributeError:
        # Django older than May 17, 2007
        clean_data = form.clean_data

    for f in opts.fields:
        if isinstance(f, models.AutoField):
            continue

        # Changed from stock newforms:
        # only set values for fields actually found in the form
        # and keep old values for the rest of the fields
        if f.name in clean_data:
            value = clean_data[f.name]
            if isinstance(value, models.Model):
                value = value._get_pk_val()
            setattr(instance, f.attname, value)

    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_instance(instance, form=forms.BaseForm,
                      formfield_callback=lambda f, **kwargs:
                      f.formfield(**kwargs),
                      include_fields=None, exclude_fields=None):
    """
    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').

    Changed from stock newforms:
    - added parameters ``include_fields`` and ``exclude_fields``:
      * if ``include_fields`` is specified, only fieldnames in that
        list are used in the form
      * if ``exclude_fields`` is specified, fieldnames in that list
        are not used in the form
      * both ``include_fields`` and ``exclude_fields`` cannot be
        specified at the same time
    """
    if include_fields is not None and exclude_fields is not None:
        raise ValueError("form_for_instance can't use both "
                         "include_fields and exclude_fields at the same time")
    model = instance.__class__
    opts = model._meta
    field_list = []
    for f in opts.fields + opts.many_to_many:

        # Changed from stock newforms:
        # Do not use fields which are not in ``include_fields`` (if it is
        # specified) or which are in ``exclude_fields`` (if it is specified).
        if (include_fields and f.name not in include_fields) or \
           (exclude_fields and f.name in exclude_fields):
            continue

        current_value = f.value_from_object(instance)
        formfield = formfield_callback(f, initial=current_value)
        if formfield:
            field_list.append((f.name, formfield))
    fields = forms.SortedDictFromList(field_list)
    return type(opts.object_name + 'InstanceForm', (form,),
        {'base_fields': fields,
         '_model': model,
         'save': make_instance_save(instance)})


def get_changed_fields(form, instance, fields=None):
    """
    Compare the validated form to the given instance and return a list of
    fields whose values don't match.  The ``fields`` keyword argument can be
    used to specify a limited set of fields to compare.  All fields are
    compared by default.
    """
    opts = instance._meta
    cleaned_data = form.cleaned_data
    changed_field_names = set()
    for f in opts.fields:
        if fields and f.name not in fields:
            continue
        if f.name in cleaned_data:
            if getattr(instance, f.name) != cleaned_data[f.name]:
                changed_field_names.add(f.name)
    for f in opts.many_to_many:
        if fields and f.name not in fields:
            continue
        if f.name in cleaned_data:
            if instance.pk is None: # creating a new object
                changed_field_names.add(f.name)
                continue
            instvalue = set(field._get_pk_val()
                            for field in getattr(instance, f.name).all())
            formvalue = set(field._get_pk_val()
                            for field in cleaned_data[f.name])
            if instvalue != formvalue:
                changed_field_names.add(f.name)
    return changed_field_names


if hasattr(forms.models, 'InlineFormset'):
    def inline_formset(parent_model, model,
                       form=forms.BaseForm, formset=forms.models.InlineFormset,
                       fk_name=None, fields=None, extra=3, orderable=False,
                       deletable=True, formfield_callback=lambda f: f.formfield()):
        """
        Returns an ``InlineFormset`` for the given kwargs.

        You must provide ``fk_name`` if ``model`` has more than one ``ForeignKey``
        to ``parent_model``.

        This modified version of the ``newforms.models.inline_formset()`` function
        is a temporary fix while #5759 is not yet fixed.  -- akaihola 2007-10-15
        """
        fk = forms.models.get_foreign_key(parent_model, model, fk_name=fk_name)
        FormSet = forms.formset_for_model(model, formset=formset, fields=fields,
                                          formfield_callback=formfield_callback,
                                          extra=extra, orderable=orderable,
                                          deletable=deletable, form=form)
        try:
            del FormSet.form_class.base_fields[fk.name]
        except KeyError:
            pass
        FormSet.fk = fk
        return FormSet


if hasattr(forms, 'ModelForm'):

    # ModelForms have been in Django since r6844.  These classes implement
    # enhancements to them.

    class SmartModelFormData:
        """
        Helper class for SmartModelForm.
        """
        def __init__(self, form):
            self.form = form
        def __getitem__(self, attr):
            return self.form._get_field_val(attr)

    class SmartModelForm(forms.ModelForm):
        """
        With this model form base class you can access underlying form data in a
        template:

        {{ myform.field_values.fieldname }}

        This is useful if you need to display some data from the model instance
        without having a form field for it.
        """
        def __init__(self, *args, **kwargs):
            super(SmartModelForm, self).__init__(*args, **kwargs)
            self.field_values = SmartModelFormData(self)

        def _get_field_val(self, fieldname):
            """
            Return the value for the given field from the POST data for bound forms
            and initial data for non-bound forms.  This is really just a hack...
            """
            if self.is_bound:
                if fieldname in self:
                    value = self[fieldname].data
                else:
                    value = None
            else:
                value = self.initial.get(fieldname, None)
            if value is not None:
                from django.db import models
                field = self._meta.model._meta.get_field(fieldname)
                if isinstance(field, models.ForeignKey):
                    value = field.rel.to.objects.get(pk=value)
            return value