def get_model_and_form_class(model, form_class):
"""
Returns a model and form class based on the model and form_class
parameters that were passed to the generic view.
If ``form_class`` is given then its associated model will be returned along
with ``form_class`` itself. Otherwise, if ``model`` is given, ``model``
itself will be returned along with a ``ModelForm`` class created from
``model``.
"""
if form_class:
return form_class._meta.model, form_class
if model:
# The inner Meta class fails if model = model is used for some reason.
tmp_model = model
# TODO: we should be able to construct a ModelForm without creating
# and passing in a temporary inner class.
class Meta:
model = tmp_model
class_name = model.__name__ + 'Form'
form_class = ModelFormMetaclass(class_name, (ModelForm, ),
{'Meta': Meta})
return model, form_class
raise GenericViewError("Generic view must be called with either a model or"
" form_class argument.")
def __new__(cls, name, bases, attrs):
exclude = list(getattr(attrs.get('Meta', None), 'exclude', []))
if exclude:
populate_exclude(exclude, attrs['Meta'].model)
attrs['Meta'].exclude = exclude
attrs['formfield_callback'] = formfield_exclude_translations
return ModelFormMetaclass.__new__(cls, name, bases, attrs)
def make_localised_form(model, form, exclude=None):
"""
This is a factory function that creates a form for a model with internationalised
field. The model should be decorated with the L10N decorater.
"""
newfields = {}
for localized_field in model.localized_fields:
# get the descriptor, which contains the form field
default_field_descriptor = getattr(model, localized_field)
# See if we've got overridden fields in a custom form.
if hasattr(form, 'declared_fields'):
form_field = form.declared_fields.get(
localized_field, default_field_descriptor.form_field)
else:
form_field = default_field_descriptor.form_field
# wrap the widget to show the origin of the value;
# either database, catalog or fallback.
if type(form_field.widget) is not WidgetWrapper:
form_field.widget = WidgetWrapper(form_field.widget)
newfields[localized_field] = form_field
if hasattr(form, 'Meta'):
setattr(form.Meta, 'model', model)
else:
newfields['Meta'] = type('Meta', tuple(), {'model': model})
newfields['localized_fields'] = model.localized_fields
return ModelFormMetaclass(model.__name__, (LocalisedForm, form), newfields)
def __new__(mcs, name, bases, attrs):
if attrs is None:
attrs = {}
bases = bases + (UnchangeableModelMixin,)
attrs['formfield_callback'] = display_model_formfield_callback
if 'template_dir' not in attrs:
attrs['template_dir'] = 'render/display/'
return ModelFormMetaclass.__new__(mcs, name, bases, attrs)
def __new__(cls, name, bases, attrs):
attrs['Meta'] = attrs.get('Meta', type(name + '.Meta', (object,), {}))
if hasattr(attrs['Meta'], 'model'):
new_class = ModelFormMetaclass.__new__(cls, name, bases + (DjangoModelForm,), attrs)
new_class._base_form = DjangoModelForm
else:
new_class = DeclarativeFieldsMetaclass.__new__(cls, name, bases + (DjangoForm,), attrs)
new_class._base_form = DjangoForm
return new_class
def __new__(cls, name, bases, attrs):
if 'custom_fields' in attrs:
custom_fields = {}
for custom_field in attrs.get('custom_fields'):
key = 'custom_field_%d' % custom_field.id
attrs[key] = custom_field.get_field_class()
custom_fields[key] = custom_field
attrs['custom_fields'] = custom_fields
return ModelFormMetaclass.__new__(cls, name, bases, attrs)
def __init__(cls, name, bases, attrs):
ModelFormMetaclass.__init__(cls, name, bases, attrs)
if cls._meta.model:
model = cls._meta.model
elif hasattr(bases[0], '_meta') and bases[0]._meta.model:
# apparently, _meta has not been created yet if inherited, so use parent's (if any)
model = bases[0]._meta.model
else:
model = None
if model:
mdlfields = model._meta.get_all_field_names()
for fldname in cls.base_fields:
if fldname in mdlfields:
continue
prop = getattr(model, fldname)
if prop.__doc__:
cls.base_fields[fldname].label = _(prop.__doc__)
def test_valid_loading_order(self):
"""
Test for issue 10405
"""
class A(models.Model):
ref = models.ForeignKey("B")
class B(models.Model):
pass
class Meta:
model=A
self.assertTrue(issubclass(ModelFormMetaclass(str('Form'), (ModelForm,), {'Meta': Meta}), ModelForm))
def test_valid_loading_order(self):
"""
Test for issue 10405
"""
class C(models.Model):
ref = models.ForeignKey("D", models.CASCADE)
class D(models.Model):
pass
class Meta:
model = C
fields = '__all__'
self.assertTrue(issubclass(ModelFormMetaclass('Form', (ModelForm,), {'Meta': Meta}), ModelForm))
def test_invalid_loading_order(self):
"""
Test for issue 10405
"""
class A(models.Model):
ref = models.ForeignKey("B", models.CASCADE)
class Meta:
model = A
fields = '__all__'
with self.assertRaises(ValueError):
ModelFormMetaclass(str('Form'), (ModelForm, ), {'Meta': Meta})
class B(models.Model):
pass
def test_invalid_loading_order(self):
"""
Test for issue 10405
"""
class A(models.Model):
ref = models.ForeignKey("B", models.CASCADE)
class Meta:
model = A
fields = "__all__"
msg = ("Cannot create form field for 'ref' yet, because "
"its related model 'B' has not been loaded yet")
with self.assertRaisesMessage(ValueError, msg):
ModelFormMetaclass("Form", (ModelForm, ), {"Meta": Meta})
class B(models.Model):
pass
def contenttype_inlineformset_factory(parent_model, model, admin_site,
formfield_callback,
extra=3, can_order=False,
can_delete=True, max_num=0):
fk = _get_foreign_key(parent_model, model)
Meta = type('Meta', (MenuItemForm.Meta,), {'model': model})
class_name = model.__name__ + 'Form'
form_class_attrs = {
'admin_site': admin_site,
'Meta': Meta,
'formfield_callback': formfield_callback
}
form = ModelFormMetaclass(class_name, (MenuItemForm,), form_class_attrs)
FormSet = formset_factory(form, BaseInlineFormSet, extra=extra,
max_num=max_num,
can_order=can_order, can_delete=can_delete)
FormSet.model = model
FormSet.fk = fk
return FormSet
def __new__(mcs, name, bases, attrs):
if attrs is None:
attrs = {}
bases = bases + (UnchangableModelMixin, )
attrs.update({'formfield_callback': display_model_formfield_callback})
return ModelFormMetaclass.__new__(mcs, name, bases, attrs)
def __new__(mcs, name, bases, attrs):
if attrs is None:
attrs = {}
bases = bases + (UnchangableModelMixin,)
attrs.update({'formfield_callback': display_model_formfield_callback})
return ModelFormMetaclass.__new__(mcs, name, bases, attrs)
def __new__(cls, name, bases, attrs):
exclude = list(getattr(attrs.get('Meta', None), 'exclude', []))
if exclude:
populate_exclude(exclude, attrs['Meta'].model)
attrs['Meta'].exclude = exclude
return ModelFormMetaclass.__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, attrs):
new_class = ModelFormMetaclass.__new__(cls, name, bases, attrs)
new_class.multi_language_fields = getattr(attrs.get('Meta', None), 'multi_language_fields', None)
return new_class
