"contact_email",

            "level"

        ]

    def save(self, commit=True):

        obj = super(SponsorApplicationForm, self).save(commit=False)

        obj.applicant = self.user

        if commit:

            obj.save()

        return obj

class SponsorDetailsForm(forms.ModelForm):

    class Meta:

        model = Sponsor

        fields = [

            "name",

            "external_url",

            "contact_name",

            "contact_email"

        ]

class SponsorBenefitsInlineFormSet(BaseInlineFormSet):

    def _construct_form(self, i, **kwargs):

        form = super(SponsorBenefitsInlineFormSet, self)._construct_form(i, **kwargs)

        # only include the relevant data fields for this benefit type

        fields = form.instance.data_fields()

        form.fields = dict((k, v) for (k, v) in form.fields.items() if k in fields + ["id"])

        for field in fields:

            # don't need a label, the form template will label it with the benefit name

            form.fields[field].label = ""

            # provide word limit as help_text

            if form.instance.benefit.type == "text" and form.instance.max_words:

                form.fields[field].help_text = u"maximum %s words" % form.instance.max_words

            # use admin file widget that shows currently uploaded file

            if field == "upload":

                form.fields[field].widget = AdminFileWidget()

        return form

SponsorBenefitsFormSet = inlineformset_factory(

class SponsorBenefit(models.Model):

    sponsor = models.ForeignKey(Sponsor, related_name="sponsor_benefits", verbose_name=_("sponsor"))

    benefit = models.ForeignKey(Benefit, related_name="sponsor_benefits", verbose_name=_("benefit"))

    active = models.BooleanField(default=True)

    # Limits: will initially be set to defaults from corresponding BenefitLevel

    max_words = models.PositiveIntegerField(_("max words"), blank=True, null=True)

    other_limits = models.CharField(_("other limits"), max_length=200, blank=True)

    # Data: zero or one of these fields will be used, depending on the

    # type of the Benefit (text, file, or simple)

    text = models.TextField(_("text"), blank=True)

    upload = models.FileField(_("file"), blank=True, upload_to="sponsor_files")

    # Whether any assets required from the sponsor have been provided

    # (e.g. a logo file for a Web logo benefit).

    is_complete = models.NullBooleanField(_("Complete?"), help_text=_(u"True - benefit complete; False - benefit incomplete; Null - n/a"))

    class Meta:

        ordering = ["-active"]

    def __unicode__(self):

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

        # Validate - save() doesn't clean your model by default, so call

        # it explicitly before saving

        self.full_clean()

        self.is_complete = self._is_complete()

        super(SponsorBenefit, self).save(*args, **kwargs)

    def clean(self):

        num_words = len(self.text.split())

        if self.max_words and num_words > self.max_words:

            raise ValidationError(

                "Sponsorship level only allows for %s words, you provided %d." % (

                    self.max_words, num_words))

    def data_fields(self):

        """

        Return list of data field names which should be editable for

        this ``SponsorBenefit``, depending on its ``Benefit`` type.

        """

        if self.benefit.type == "file" or self.benefit.type == "weblogo":

            return ["upload"]

            return ["text"]

        return []

    def _is_complete(self):

        return self.active and \

            ((self.benefit.type in ('text', 'richtext', 'simple') and bool(self.text))

                or (self.benefit.type in ('file', 'weblogo') and bool(self.upload)))

def _denorm_weblogo(sender, instance, created, **kwargs):

    if instance:

        if instance.benefit.type == "weblogo" and instance.upload:

            sponsor = instance.sponsor

            sponsor.sponsor_logo = instance

            sponsor.save()

post_save.connect(_denorm_weblogo, sender=SponsorBenefit)