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