"""

XX. Generating HTML forms from models

This is mostly just a reworking of the ``form_for_model``/``form_for_instance``

tests to use ``ModelForm``. As such, the text may not make sense in all cases,

and the examples are probably a poor fit for the ``ModelForm`` syntax. In other

words, most of these tests should be rewritten.

"""

import os

import tempfile

from django.db import models

from django.core.files.storage import FileSystemStorage

temp_storage_dir = tempfile.mkdtemp()

temp_storage = FileSystemStorage(temp_storage_dir)

ARTICLE_STATUS = (

    (1, 'Draft'),

    (2, 'Pending'),

    (3, 'Live'),

)

ARTICLE_STATUS_CHAR = (

    ('d', 'Draft'),

    ('p', 'Pending'),

    ('l', 'Live'),

)

class Category(models.Model):

    name = models.CharField(max_length=20)

    slug = models.SlugField(max_length=20)

    url = models.CharField('The URL', max_length=40)

    def __unicode__(self):

        return self.name

class Writer(models.Model):

    name = models.CharField(max_length=50, help_text='Use both first and last names.')

    def __unicode__(self):

        return self.name

class Article(models.Model):

    headline = models.CharField(max_length=50)

    slug = models.SlugField()

    pub_date = models.DateField()

    created = models.DateField(editable=False)

    writer = models.ForeignKey(Writer)

    article = models.TextField()

    categories = models.ManyToManyField(Category, blank=True)

    status = models.PositiveIntegerField(choices=ARTICLE_STATUS, blank=True, null=True)

    def save(self):

        import datetime

        if not self.id:

            self.created = datetime.date.today()

        return super(Article, self).save()

    def __unicode__(self):

        return self.headline

class ImprovedArticle(models.Model):

    article = models.OneToOneField(Article)

class ImprovedArticleWithParentLink(models.Model):

    article = models.OneToOneField(Article, parent_link=True)

class BetterWriter(Writer):

    score = models.IntegerField()

class WriterProfile(models.Model):

    writer = models.OneToOneField(Writer, primary_key=True)

    age = models.PositiveIntegerField()

    def __unicode__(self):

        return "%s is %s" % (self.writer, self.age)

from django.contrib.localflavor.us.models import PhoneNumberField

class PhoneNumber(models.Model):

    phone = PhoneNumberField()

    description = models.CharField(max_length=20)

    def __unicode__(self):

        return self.phone

class TextFile(models.Model):

    description = models.CharField(max_length=20)

    file = models.FileField(storage=temp_storage, upload_to='tests', max_length=15)

    def __unicode__(self):

        return self.description

try:

    # If PIL is available, try testing ImageFields. Checking for the existence

    # of Image is enough for CPython, but for PyPy, you need to check for the

    # underlying modules If PIL is not available, ImageField tests are omitted.

    # Try to import PIL in either of the two ways it can end up installed.

    try:

        from PIL import Image, _imaging

    except ImportError:

        import Image, _imaging

    test_images = True

    class ImageFile(models.Model):

        def custom_upload_path(self, filename):

            path = self.path or 'tests'

            return '%s/%s' % (path, filename)

        description = models.CharField(max_length=20)

        # Deliberately put the image field *after* the width/height fields to

        # trigger the bug in #10404 with width/height not getting assigned.

        width = models.IntegerField(editable=False)

        height = models.IntegerField(editable=False)

        image = models.ImageField(storage=temp_storage, upload_to=custom_upload_path,

                                  width_field='width', height_field='height')

        path = models.CharField(max_length=16, blank=True, default='')

        def __unicode__(self):

            return self.description

    class OptionalImageFile(models.Model):

        def custom_upload_path(self, filename):

            path = self.path or 'tests'

            return '%s/%s' % (path, filename)

        description = models.CharField(max_length=20)

        image = models.ImageField(storage=temp_storage, upload_to=custom_upload_path,

                                  width_field='width', height_field='height',

                                  blank=True, null=True)

        width = models.IntegerField(editable=False, null=True)

        height = models.IntegerField(editable=False, null=True)

        path = models.CharField(max_length=16, blank=True, default='')

        def __unicode__(self):

            return self.description

except ImportError:

    test_images = False

class CommaSeparatedInteger(models.Model):

    field = models.CommaSeparatedIntegerField(max_length=20)

    def __unicode__(self):

        return self.field

class Product(models.Model):

    slug = models.SlugField(unique=True)

    def __unicode__(self):

        return self.slug

class Price(models.Model):

    price = models.DecimalField(max_digits=10, decimal_places=2)

    quantity = models.PositiveIntegerField()

    def __unicode__(self):

        return u"%s for %s" % (self.quantity, self.price)

    class Meta:

        unique_together = (('price', 'quantity'),)

class ArticleStatus(models.Model):

    status = models.CharField(max_length=2, choices=ARTICLE_STATUS_CHAR, blank=True, null=True)

class Inventory(models.Model):

   barcode = models.PositiveIntegerField(unique=True)

   parent = models.ForeignKey('self', to_field='barcode', blank=True, null=True)

   name = models.CharField(blank=False, max_length=20)

   def __unicode__(self):

      return self.name

class Book(models.Model):

    title = models.CharField(max_length=40)

    author = models.ForeignKey(Writer, blank=True, null=True)

    special_id = models.IntegerField(blank=True, null=True, unique=True)

    class Meta:

        unique_together = ('title', 'author')

class BookXtra(models.Model):

    isbn = models.CharField(max_length=16, unique=True)

    suffix1 = models.IntegerField(blank=True, default=0)

    suffix2 = models.IntegerField(blank=True, default=0)

    class Meta:

        unique_together = (('suffix1', 'suffix2'))

        abstract = True

class DerivedBook(Book, BookXtra):

    pass

class ExplicitPK(models.Model):

    key = models.CharField(max_length=20, primary_key=True)

    desc = models.CharField(max_length=20, blank=True, unique=True)

    class Meta:

        unique_together = ('key', 'desc')

    def __unicode__(self):

        return self.key

class Post(models.Model):

    title = models.CharField(max_length=50, unique_for_date='posted', blank=True)

    slug = models.CharField(max_length=50, unique_for_year='posted', blank=True)

    subtitle = models.CharField(max_length=50, unique_for_month='posted', blank=True)

    posted = models.DateField()

    def __unicode__(self):

        return self.name

class DerivedPost(Post):

    pass

class BigInt(models.Model):

    biggie = models.BigIntegerField()

    def __unicode__(self):

        return unicode(self.biggie)

class MarkupField(models.CharField):

    def __init__(self, *args, **kwargs):

        kwargs["max_length"] = 20

        super(MarkupField, self).__init__(*args, **kwargs)

    def formfield(self, **kwargs):

        # don't allow this field to be used in form (real use-case might be

        # that you know the markup will always be X, but it is among an app

        # that allows the user to say it could be something else)

        # regressed at r10062

        return None

class CustomFieldForExclusionModel(models.Model):

    name = models.CharField(max_length=10)

    markup = MarkupField()

__test__ = {'API_TESTS': """

>>> from django import forms

>>> from django.forms.models import ModelForm, model_to_dict

>>> from django.core.files.uploadedfile import SimpleUploadedFile

The bare bones, absolutely nothing custom, basic case.

>>> class CategoryForm(ModelForm):

...     class Meta:

...         model = Category

>>> CategoryForm.base_fields.keys()

['name', 'slug', 'url']

Extra fields.

>>> class CategoryForm(ModelForm):

...     some_extra_field = forms.BooleanField()

...

...     class Meta:

...         model = Category

>>> CategoryForm.base_fields.keys()

['name', 'slug', 'url', 'some_extra_field']

Extra field that has a name collision with a related object accessor.

>>> class WriterForm(ModelForm):

...     book = forms.CharField(required=False)

...

...     class Meta:

...         model = Writer

>>> wf = WriterForm({'name': 'Richard Lockridge'})

>>> wf.is_valid()

True

Replacing a field.

>>> class CategoryForm(ModelForm):

...     url = forms.BooleanField()

...

...     class Meta:

...         model = Category

>>> CategoryForm.base_fields['url'].__class__

<class 'django.forms.fields.BooleanField'>

Using 'fields'.

>>> class CategoryForm(ModelForm):

...

...     class Meta:

...         model = Category

...         fields = ['url']

>>> CategoryForm.base_fields.keys()

['url']

Using 'exclude'

>>> class CategoryForm(ModelForm):

...

...     class Meta:

...         model = Category

...         exclude = ['url']

>>> CategoryForm.base_fields.keys()

['name', 'slug']

Using 'fields' *and* 'exclude'. Not sure why you'd want to do this, but uh,

"be liberal in what you accept" and all.

>>> class CategoryForm(ModelForm):

...

...     class Meta:

...         model = Category

...         fields = ['name', 'url']

...         exclude = ['url']

>>> CategoryForm.base_fields.keys()

['name']

Using 'widgets'

>>> class CategoryForm(ModelForm):

...

...     class Meta:

...         model = Category

...         fields = ['name', 'url', 'slug']

...         widgets = {

...             'name': forms.Textarea,

...             'url': forms.TextInput(attrs={'class': 'url'})

...         }

>>> str(CategoryForm()['name'])

'<textarea id="id_name" rows="10" cols="40" name="name"></textarea>'

>>> str(CategoryForm()['url'])

'<input id="id_url" type="text" class="url" name="url" maxlength="40" />'

>>> str(CategoryForm()['slug'])

'<input id="id_slug" type="text" name="slug" maxlength="20" />'

Don't allow more than one 'model' definition in the inheritance hierarchy.

Technically, it would generate a valid form, but the fact that the resulting

save method won't deal with multiple objects is likely to trip up people not

familiar with the mechanics.

>>> class CategoryForm(ModelForm):

...     class Meta:

...         model = Category

>>> class OddForm(CategoryForm):

...     class Meta:

...         model = Article

OddForm is now an Article-related thing, because BadForm.Meta overrides

CategoryForm.Meta.

>>> OddForm.base_fields.keys()

['headline', 'slug', 'pub_date', 'writer', 'article', 'status', 'categories']

>>> class ArticleForm(ModelForm):

...     class Meta:

...         model = Article

First class with a Meta class wins.

>>> class BadForm(ArticleForm, CategoryForm):

...     pass

>>> OddForm.base_fields.keys()

['headline', 'slug', 'pub_date', 'writer', 'article', 'status', 'categories']

Subclassing without specifying a Meta on the class will use the parent's Meta

(or the first parent in the MRO if there are multiple parent classes).

>>> class CategoryForm(ModelForm):

...     class Meta:

...         model = Category

>>> class SubCategoryForm(CategoryForm):

...     pass

>>> SubCategoryForm.base_fields.keys()

['name', 'slug', 'url']

We can also subclass the Meta inner class to change the fields list.

>>> class CategoryForm(ModelForm):

...     checkbox = forms.BooleanField()

...

...     class Meta:

...         model = Category

>>> class SubCategoryForm(CategoryForm):

...     class Meta(CategoryForm.Meta):

...         exclude = ['url']

>>> print SubCategoryForm()

<tr><th><label for="id_name">Name:</label></th><td><input id="id_name" type="text" name="name" maxlength="20" /></td></tr>

<tr><th><label for="id_slug">Slug:</label></th><td><input id="id_slug" type="text" name="slug" maxlength="20" /></td></tr>

<tr><th><label for="id_checkbox">Checkbox:</label></th><td><input type="checkbox" name="checkbox" id="id_checkbox" /></td></tr>

# test using fields to provide ordering to the fields

>>> class CategoryForm(ModelForm):

...     class Meta:

...         model = Category

...         fields = ['url', 'name']

>>> CategoryForm.base_fields.keys()

['url', 'name']

>>> print CategoryForm()

<tr><th><label for="id_url">The URL:</label></th><td><input id="id_url" type="text" name="url" maxlength="40" /></td></tr>

<tr><th><label for="id_name">Name:</label></th><td><input id="id_name" type="text" name="name" maxlength="20" /></td></tr>

>>> class CategoryForm(ModelForm):

...     class Meta:

...         model = Category

...         fields = ['slug', 'url', 'name']

...         exclude = ['url']

>>> CategoryForm.base_fields.keys()

['slug', 'name']

# Old form_for_x tests #######################################################

>>> from django.forms import ModelForm, CharField

>>> import datetime

>>> Category.objects.all()

[]

>>> class CategoryForm(ModelForm):

...     class Meta:

...         model = Category

>>> f = CategoryForm()

>>> print f

<tr><th><label for="id_name">Name:</label></th><td><input id="id_name" type="text" name="name" maxlength="20" /></td></tr>

<tr><th><label for="id_slug">Slug:</label></th><td><input id="id_slug" type="text" name="slug" maxlength="20" /></td></tr>

<tr><th><label for="id_url">The URL:</label></th><td><input id="id_url" type="text" name="url" maxlength="40" /></td></tr>

>>> print f.as_ul()

<li><label for="id_name">Name:</label> <input id="id_name" type="text" name="name" maxlength="20" /></li>

<li><label for="id_slug">Slug:</label> <input id="id_slug" type="text" name="slug" maxlength="20" /></li>

<li><label for="id_url">The URL:</label> <input id="id_url" type="text" name="url" maxlength="40" /></li>

>>> print f['name']

<input id="id_name" type="text" name="name" maxlength="20" />

>>> f = CategoryForm(auto_id=False)

>>> print f.as_ul()

<li>Name: <input type="text" name="name" maxlength="20" /></li>

<li>Slug: <input type="text" name="slug" maxlength="20" /></li>

<li>The URL: <input type="text" name="url" maxlength="40" /></li>

>>> f = CategoryForm({'name': 'Entertainment', 'slug': 'entertainment', 'url': 'entertainment'})

>>> f.is_valid()

True

>>> f.cleaned_data['url']

u'entertainment'

>>> f.cleaned_data['name']

u'Entertainment'

>>> f.cleaned_data['slug']

u'entertainment'

>>> obj = f.save()

>>> obj

<Category: Entertainment>

>>> Category.objects.all()

[<Category: Entertainment>]

>>> f = CategoryForm({'name': "It's a test", 'slug': 'its-test', 'url': 'test'})

>>> f.is_valid()

True

>>> f.cleaned_data['url']

u'test'

>>> f.cleaned_data['name']

u"It's a test"

>>> f.cleaned_data['slug']

u'its-test'

>>> obj = f.save()

>>> obj

<Category: It's a test>

>>> Category.objects.order_by('name')

[<Category: Entertainment>, <Category: It's a test>]

If you call save() with commit=False, then it will return an object that

hasn't yet been saved to the database. In this case, it's up to you to call

save() on the resulting model instance.

>>> f = CategoryForm({'name': 'Third test', 'slug': 'third-test', 'url': 'third'})

>>> f.is_valid()

True

>>> f.cleaned_data['url']

u'third'

>>> f.cleaned_data['name']

u'Third test'

>>> f.cleaned_data['slug']

u'third-test'

>>> obj = f.save(commit=False)

>>> obj

<Category: Third test>

>>> Category.objects.order_by('name')

[<Category: Entertainment>, <Category: It's a test>]

>>> obj.save()

>>> Category.objects.order_by('name')

[<Category: Entertainment>, <Category: It's a test>, <Category: Third test>]

If you call save() with invalid data, you'll get a ValueError.

>>> f = CategoryForm({'name': '', 'slug': 'not a slug!', 'url': 'foo'})

>>> f.errors['name']

[u'This field is required.']

>>> f.errors['slug']

[u"Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens."]

>>> f.cleaned_data

Traceback (most recent call last):

...

AttributeError: 'CategoryForm' object has no attribute 'cleaned_data'

>>> f.save()

Traceback (most recent call last):

...

ValueError: The Category could not be created because the data didn't validate.

>>> f = CategoryForm({'name': '', 'slug': '', 'url': 'foo'})

>>> f.save()

Traceback (most recent call last):

...

ValueError: The Category could not be created because the data didn't validate.

Create a couple of Writers.

>>> w_royko = Writer(name='Mike Royko')

>>> w_royko.save()

>>> w_woodward = Writer(name='Bob Woodward')

>>> w_woodward.save()