"""

Helper functions for creating Form classes from Django models

and database field objects.

"""

from django.db import connections

from django.utils.encoding import smart_unicode, force_unicode

from django.utils.datastructures import SortedDict

from django.utils.text import get_text_list, capfirst

from django.utils.translation import ugettext_lazy as _, ugettext

from django.core.exceptions import ValidationError, NON_FIELD_ERRORS

from django.core.validators import EMPTY_VALUES

from util import ErrorList

from forms import BaseForm, get_declared_fields

from fields import Field, ChoiceField

from widgets import SelectMultiple, HiddenInput, MultipleHiddenInput

from widgets import media_property

from formsets import BaseFormSet, formset_factory, DELETION_FIELD_NAME

__all__ = (

    'ModelForm', 'BaseModelForm', 'model_to_dict', 'fields_for_model',

    'save_instance', 'form_for_fields', 'ModelChoiceField',

    'ModelMultipleChoiceField',

)

def construct_instance(form, instance, fields=None, exclude=None):

    """

    Constructs and returns a model instance from the bound ``form``'s

    ``cleaned_data``, but does not save the returned instance to the

    database.

    """

    from django.db import models

    opts = instance._meta

    cleaned_data = form.cleaned_data

    file_field_list = []

    for f in opts.fields:

        if not f.editable or isinstance(f, models.AutoField) \

                or not f.name in cleaned_data:

            continue

        if fields and f.name not in fields:

            continue

        if exclude and f.name in exclude:

            continue

        # Defer saving file-type fields until after the other fields, so a

        # callable upload_to can use the values from other fields.

        if isinstance(f, models.FileField):

            file_field_list.append(f)

        else:

            f.save_form_data(instance, cleaned_data[f.name])

    for f in file_field_list:

        f.save_form_data(instance, cleaned_data[f.name])

    return instance

def save_instance(form, instance, fields=None, fail_message='saved',

                  commit=True, exclude=None, construct=True):

    """

    Saves bound Form ``form``'s cleaned_data into model instance ``instance``.

    If commit=True, then the changes to ``instance`` will be saved to the

    database. Returns ``instance``.

    If construct=False, assume ``instance`` has already been constructed and

    just needs to be saved.

    """

    if construct:

        instance = construct_instance(form, instance, fields, exclude)

    opts = instance._meta

    if form.errors:

        raise ValueError("The %s could not be %s because the data didn't"

                         " validate." % (opts.object_name, fail_message))

    # Wrap up the saving of m2m data as a function.

    def save_m2m():

        cleaned_data = form.cleaned_data

        for f in opts.many_to_many:

            if fields and f.name not in fields:

                continue

            if f.name in cleaned_data:

                f.save_form_data(instance, cleaned_data[f.name])

    if commit:

        # If we are committing, save the instance and the m2m data immediately.

        instance.save()

        save_m2m()

    else:

        # We're not committing. Add a method to the form to allow deferred

        # saving of m2m data.

        form.save_m2m = save_m2m

    return instance

def make_model_save(model, fields, fail_message):

    """Returns the save() method for a Form."""

    def save(self, commit=True):

        return save_instance(self, model(), fields, fail_message, commit)

    return save

def make_instance_save(instance, fields, fail_message):

    """Returns the save() method for a Form."""

    def save(self, commit=True):

        return save_instance(self, instance, fields, fail_message, commit)

    return save

def form_for_fields(field_list):

    """

    Returns a Form class for the given list of Django database field instances.

    """

    fields = SortedDict([(f.name, f.formfield())

                         for f in field_list if f.editable])

    return type('FormForFields', (BaseForm,), {'base_fields': fields})

# ModelForms #################################################################

def model_to_dict(instance, fields=None, exclude=None):

    """

    Returns a dict containing the data in ``instance`` suitable for passing as

    a Form's ``initial`` keyword argument.

    ``fields`` is an optional list of field names. If provided, only the named

    fields will be included in the returned dict.

    ``exclude`` is an optional list of field names. If provided, the named

    fields will be excluded from the returned dict, even if they are listed in

    the ``fields`` argument.

    """

    # avoid a circular import

    from django.db.models.fields.related import ManyToManyField

    opts = instance._meta

    data = {}

    for f in opts.fields + opts.many_to_many:

        if not f.editable:

            continue

        if fields and not f.name in fields:

            continue

        if exclude and f.name in exclude:

            continue

        if isinstance(f, ManyToManyField):

            # If the object doesn't have a primry key yet, just use an empty

            # list for its m2m fields. Calling f.value_from_object will raise

            # an exception.

            if instance.pk is None:

                data[f.name] = []

            else:

                # MultipleChoiceWidget needs a list of pks, not object instances.

                data[f.name] = [obj.pk for obj in f.value_from_object(instance)]

        else:

            data[f.name] = f.value_from_object(instance)

    return data

def fields_for_model(model, fields=None, exclude=None, widgets=None, formfield_callback=lambda f, **kwargs: f.formfield(**kwargs)):

    """

    Returns a ``SortedDict`` containing form fields for the given model.

    ``fields`` is an optional list of field names. If provided, only the named

    fields will be included in the returned fields.

    ``exclude`` is an optional list of field names. If provided, the named

    fields will be excluded from the returned fields, even if they are listed

    in the ``fields`` argument.

    """

    field_list = []

    ignored = []

    opts = model._meta

    for f in opts.fields + opts.many_to_many:

        if not f.editable:

            continue

        if fields and not f.name in fields:

            continue

        if exclude and f.name in exclude:

            continue

        if widgets and f.name in widgets:

            kwargs = {'widget': widgets[f.name]}

        else:

            kwargs = {}

        formfield = formfield_callback(f, **kwargs)

        if formfield:

            field_list.append((f.name, formfield))

        else:

            ignored.append(f.name)

    field_dict = SortedDict(field_list)

    if fields:

        field_dict = SortedDict(

            [(f, field_dict.get(f)) for f in fields

                if ((not exclude) or (exclude and f not in exclude)) and (f not in ignored)]

        )

    return field_dict

class ModelFormOptions(object):

    def __init__(self, options=None):

        self.model = getattr(options, 'model', None)

        self.fields = getattr(options, 'fields', None)

        self.exclude = getattr(options, 'exclude', None)

        self.widgets = getattr(options, 'widgets', None)

class ModelFormMetaclass(type):

    def __new__(cls, name, bases, attrs):

        formfield_callback = attrs.pop('formfield_callback',

                lambda f, **kwargs: f.formfield(**kwargs))

        try:

            parents = [b for b in bases if issubclass(b, ModelForm)]

        except NameError:

            # We are defining ModelForm itself.

            parents = None

        declared_fields = get_declared_fields(bases, attrs, False)

        new_class = super(ModelFormMetaclass, cls).__new__(cls, name, bases,

                attrs)

        if not parents:

            return new_class

        if 'media' not in attrs:

            new_class.media = media_property(new_class)

        opts = new_class._meta = ModelFormOptions(getattr(new_class, 'Meta', None))

        if opts.model:

            # If a model is defined, extract form fields from it.

            fields = fields_for_model(opts.model, opts.fields,

                                      opts.exclude, opts.widgets, formfield_callback)

            # Override default model fields with any custom declared ones

            # (plus, include all the other declared fields).

            fields.update(declared_fields)

        else:

            fields = declared_fields

        new_class.declared_fields = declared_fields

        new_class.base_fields = fields

        return new_class

class BaseModelForm(BaseForm):

    def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,

                 initial=None, error_class=ErrorList, label_suffix=':',

                 empty_permitted=False, instance=None):

        opts = self._meta

        if instance is None:

            if opts.model is None:

                raise ValueError('ModelForm has no model class specified.')

            # if we didn't get an instance, instantiate a new one

            self.instance = opts.model()

            object_data = {}

            self.instance._adding = True

        else:

            self.instance = instance

            self.instance._adding = False

            object_data = model_to_dict(instance, opts.fields, opts.exclude)

        # if initial was provided, it should override the values from instance

        if initial is not None:

            object_data.update(initial)

        # self._validate_unique will be set to True by BaseModelForm.clean().

        # It is False by default so overriding self.clean() and failing to call

        # super will stop validate_unique from being called.

        self._validate_unique = False

        super(BaseModelForm, self).__init__(data, files, auto_id, prefix, object_data,

                                            error_class, label_suffix, empty_permitted)

    def _update_errors(self, message_dict):

        for k, v in message_dict.items():

            if k != NON_FIELD_ERRORS:

                self._errors.setdefault(k, self.error_class()).extend(v)

                # Remove the data from the cleaned_data dict since it was invalid

                if k in self.cleaned_data:

                    del self.cleaned_data[k]

        if NON_FIELD_ERRORS in message_dict:

            messages = message_dict[NON_FIELD_ERRORS]

            self._errors.setdefault(NON_FIELD_ERRORS, self.error_class()).extend(messages)

    def _get_validation_exclusions(self):

        """

        For backwards-compatibility, several types of fields need to be

        excluded from model validation. See the following tickets for

        details: #12507, #12521, #12553

        """

        exclude = []

        # Build up a list of fields that should be excluded from model field

        # validation and unique checks.

        for f in self.instance._meta.fields:

            field = f.name

            # Exclude fields that aren't on the form. The developer may be

            # adding these values to the model after form validation.

            if field not in self.fields:

                exclude.append(f.name)

            # Don't perform model validation on fields that were defined

            # manually on the form and excluded via the ModelForm's Meta

            # class. See #12901.

            elif self._meta.fields and field not in self._meta.fields:

                exclude.append(f.name)

            elif self._meta.exclude and field in self._meta.exclude:

                exclude.append(f.name)

            # Exclude fields that failed form validation. There's no need for

            # the model fields to validate them as well.

            elif field in self._errors.keys():

                exclude.append(f.name)

            # Exclude empty fields that are not required by the form, if the

            # underlying model field is required. This keeps the model field

            # from raising a required error. Note: don't exclude the field from

            # validaton if the model field allows blanks. If it does, the blank

            # value may be included in a unique check, so cannot be excluded

            # from validation.

            else:

                form_field = self.fields[field]

                field_value = self.cleaned_data.get(field, None)

                if not f.blank and not form_field.required and field_value in EMPTY_VALUES:

                    exclude.append(f.name)

        return exclude

    def clean(self):

        self._validate_unique = True

        return self.cleaned_data

    def _post_clean(self):

        opts = self._meta

        # Update the model instance with self.cleaned_data.

        self.instance = construct_instance(self, self.instance, opts.fields, opts.exclude)

        exclude = self._get_validation_exclusions()

        # Foreign Keys being used to represent inline relationships

        # are excluded from basic field value validation. This is for two

        # reasons: firstly, the value may not be supplied (#12507; the

        # case of providing new values to the admin); secondly the

        # object being referred to may not yet fully exist (#12749).

        # However, these fields *must* be included in uniqueness checks,

        # so this can't be part of _get_validation_exclusions().

        for f_name, field in self.fields.items():

            if isinstance(field, InlineForeignKeyField):

                exclude.append(f_name)

        # Clean the model instance's fields.

        try:

            self.instance.clean_fields(exclude=exclude)

        except ValidationError, e:

            self._update_errors(e.message_dict)

        # Call the model instance's clean method.

        try:

            self.instance.clean()

        except ValidationError, e:

            self._update_errors({NON_FIELD_ERRORS: e.messages})

        # Validate uniqueness if needed.

        if self._validate_unique:

            self.validate_unique()

    def validate_unique(self):

        """

        Calls the instance's validate_unique() method and updates the form's

        validation errors if any were raised.

        """

        exclude = self._get_validation_exclusions()

        try:

            self.instance.validate_unique(exclude=exclude)

        except ValidationError, e:

            self._update_errors(e.message_dict)

    def save(self, commit=True):

        """

        Saves this ``form``'s cleaned_data into model instance

        ``self.instance``.

        If commit=True, then the changes to ``instance`` will be saved to the

        database. Returns ``instance``.

        """

        if self.instance.pk is None:

            fail_message = 'created'

        else:

            fail_message = 'changed'

        return save_instance(self, self.instance, self._meta.fields,

                             fail_message, commit, construct=False)

    save.alters_data = True

class ModelForm(BaseModelForm):

    __metaclass__ = ModelFormMetaclass

def modelform_factory(model, form=ModelForm, fields=None, exclude=None,

                       formfield_callback=lambda f: f.formfield()):

    # Create the inner Meta class. FIXME: ideally, we should be able to

    # construct a ModelForm without creating and passing in a temporary

    # inner class.

    # Build up a list of attributes that the Meta object will have.

    attrs = {'model': model}

    if fields is not None:

        attrs['fields'] = fields

    if exclude is not None:

        attrs['exclude'] = exclude

    # If parent form class already has an inner Meta, the Meta we're

    # creating needs to inherit from the parent's inner meta.

    parent = (object,)

    if hasattr(form, 'Meta'):

        parent = (form.Meta, object)

    Meta = type('Meta', parent, attrs)

    # Give this new form class a reasonable name.

    class_name = model.__name__ + 'Form'

    # Class attributes for the new form class.

    form_class_attrs = {

        'Meta': Meta,

        'formfield_callback': formfield_callback

    }