def render_change_form(self, request, context, add=False, change=False, form_url='', obj=None): #Verifica se a tela é readonly readonly = False readonly_fields = list(self.get_readonly_fields(request, obj)) fields = list(flatten_fieldsets(self.get_fieldsets(request, obj))) if set(fields) == set(readonly_fields).intersection(set(fields)): readonly = True for inline in context['inline_admin_formsets']: if set(flatten_fieldsets(inline.fieldsets)) != set( inline.readonly_fields).intersection( set(flatten_fieldsets(inline.fieldsets))): readonly = False opts = self.model._meta ordered_objects = opts.get_ordered_objects() object_id = obj.id if obj else obj buttons = self.get_buttons(request, object_id) context.update({ 'buttons': buttons, 'readonly': readonly, }) return super(PowerModelAdmin, self).render_change_form(request, context, add, change, form_url, obj)
def test_flatten_fieldsets(self): """ Regression test for #18051 """ fieldsets = ((None, { 'fields': ('url', 'title', ('content', 'sites')) }), ) self.assertEqual(flatten_fieldsets(fieldsets), ['url', 'title', 'content', 'sites']) fieldsets = ((None, { 'fields': ('url', 'title', ['content', 'sites']) }), ) self.assertEqual(flatten_fieldsets(fieldsets), ['url', 'title', 'content', 'sites'])
def get_form(self, request, obj=None, **kwargs): """ Returns a Form class for use in the admin add view. This is used by add_view and change_view. """ if self.declared_fieldsets is not None: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) defaults = { "form": self.form, "fields": fields, "exclude": exclude + kwargs.get("exclude", []), "formfield_callback": self.formfield_for_dbfield, } defaults.update(kwargs) form = modelform_factory(self.model, **defaults) # dirty hack for not declared fields in current tab if fields is not None and not fields: form.fields = [] form.base_fields = {} return form
def get_formset(self, request, obj=None, **kwargs): """Returns a BaseInlineFormSet class for use in admin add/change views.""" if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) defaults = { "form": self.form, "formset": self.formset, "fk_name": self.fk_name, "fields": fields, "exclude": exclude + kwargs.get("exclude", []), "formfield_callback": curry(self.formfield_for_dbfield, request=request), "extra": self.extra, "max_num": self.max_num, } defaults.update(kwargs) return inlineformset_factory(self.parent_model, self.model, **defaults)
def get_form(self, request, obj=None, **kwargs): """ Returns a Form class for use in the admin add view. This is used by add_view and change_view. """ if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) defaults = { "form": self.form, "fields": fields, "exclude": exclude + kwargs.get("exclude", []), "formfield_callback": curry(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) return modelform_factory(self.model, **defaults)
def get_formset(self, request, obj=None, **kwargs): """ Returns a BaseInlineFormSet class for use in admin add/change views. """ if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(kwargs.get("exclude", [])) exclude.extend(self.get_readonly_fields(request, obj)) # if exclude is an empty list we use None, since that's the actual # default exclude = exclude or None defaults = { "form": self.form, "formset": self.formset, "fk_name": self.fk_name, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), "extra": self.extra, "max_num": self.max_num, "can_delete": self.can_delete, } defaults.update(kwargs) return inlineformset_factory(self.parent_model, self.model, **defaults)
def get_form(self, request, obj=None, **kwargs): """ Returns a Form class for use in the admin add view. This is used by add_view and change_view. """ # fetch the model admin of the object model_admin = self.get_model_admin(obj) if model_admin.declared_fieldsets: fields = flatten_fieldsets(model_admin.declared_fieldsets) else: fields = None if model_admin.exclude is None: exclude = [] else: exclude = list(model_admin.exclude) exclude.extend(kwargs.get("exclude", [])) exclude.extend(self.get_readonly_fields(request, obj)) # if exclude is an empty list we pass None to be consistant with the # default on modelform_factory exclude = exclude or None defaults = { "form": self.get_declared_form(request, obj), "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) ### START: ADJUSTED CODE ### return modelform_factory(type(obj), **defaults)
def get_readonly_fields(self, request, obj=None): fields = set(super(ReadOnlyAdmin,self).get_readonly_fields(request, obj)) if self.declared_fieldsets: fields.update(flatten_fieldsets(self.declared_fieldsets)) else: fields.update(fields_for_model(self.model).keys()) return list(fields)
def get_readonly_fields(self, *args, **kwargs): if self.declared_fieldsets: return flatten_fieldsets(self.declared_fieldsets) else: return list( set([field.name for field in self.opts.local_fields] + [field.name for field in self.opts.local_many_to_many]))
def get_form(self, request, obj=None, **kwargs): """Return the form class to use. This method mostly delegates to the superclass, but hints that we should use :py:attr:`add_form` (and its fields) when we are creating the Application. Args: request (django.http.HttpRequest): The current HTTP request. obj (reviewboard.oauth.models.Application, optional): The application being edited, if it exists. Returns: type: The form class to use. """ if obj is None: kwargs = kwargs.copy() kwargs['form'] = self.add_form kwargs['fields'] = flatten_fieldsets(self.add_fieldsets) return super(ApplicationAdmin, self).get_form(request, obj=obj, **kwargs)
def get_formset(self, request, obj=None, **kwargs): if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) # if exclude is an empty list we use None, since that's the actual # default exclude = (exclude + kwargs.get("exclude", [])) or None defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) return reverse_inlineformset_factory(self.parent_model, self.model, self.parent_fk_name, **defaults)
def __init__(self, model, admin_site): ensure_completely_loaded() if len(model._feincms_templates) > 4 and \ 'template_key' in self.radio_fields: del(self.radio_fields['template_key']) super(PageAdmin, self).__init__(model, admin_site) # The use of fieldsets makes only fields explicitly listed in there # actually appear in the admin form. However, extensions should not be # aware that there is a fieldsets structure and even less modify it; # we therefore enumerate all of the model's field and forcibly add them # to the last section in the admin. That way, nobody is left behind. from django.contrib.admin.util import flatten_fieldsets present_fields = flatten_fieldsets(self.fieldsets) for f in self.model._meta.fields: if (not f.name.startswith('_') and not f.name in ('id', 'lft', 'rght', 'tree_id', 'level') and not f.auto_created and not f.name in present_fields and f.editable): self.fieldsets[1][1]['fields'].append(f.name) warnings.warn( 'Automatically adding %r to %r.fieldsets. This behavior' ' is deprecated. Use add_extension_options yourself if' ' you want fields to appear in the page' ' administration.' % (f.name, self.__class__), DeprecationWarning) if not f.editable: self.readonly_fields.append(f.name)
def get_form(self, request, obj=None, **kwargs): """ Returns a Form class for use in the admin add view. This is used by add_view and change_view. """ if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(kwargs.get("exclude", [])) exclude.extend(self.get_readonly_fields(request, obj)) # Exclude language_code, adding it again to the instance is done by # the LanguageAwareCleanMixin (see translatable_modelform_factory) exclude.append('language_code') old_formfield_callback = curry(self.formfield_for_dbfield, request=request) defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": old_formfield_callback, } defaults.update(kwargs) language = self._language(request) return translatable_modelform_factory(language, self.model, **defaults)
def get_formset(self, request, obj=None, **kwargs): if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(self.get_readonly_fields(request, obj)) if self.exclude is None and \ hasattr(self.form, '_meta') and self.form._meta.exclude: # Take the custom ModelForm's Meta.exclude into account only if the # InlineModelAdmin doesn't define its own. exclude.extend(self.form._meta.exclude) # if exclude is an empty list we use None, since that's the actual # default exclude = exclude or None can_delete = \ self.can_delete and self.has_delete_permission(request, obj) defaults = { "form": self.get_form(request, obj), "formset": self.formset, "fk_name": self.fk_name, "fields": fields, "exclude": exclude, "formfield_callback": partial( self.formfield_for_dbfield, request=request), "extra": self.extra, "max_num": self.max_num, "can_delete": can_delete, } defaults.update(kwargs) return inlineformset_factory(self.parent_model, self.model, **defaults)
def get_form(self, request, obj=None, **kwargs): """ Returns a Form class for use in the admin add view. This is used by add_view and change_view. UPDATE: use multilingual_modelform_factory """ if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(kwargs.get("exclude", [])) exclude.extend(self.get_readonly_fields(request, obj)) # if exclude is an empty list we pass None to be consistant with the # default on modelform_factory exclude = exclude or None defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) return multilingual_modelform_factory(self.model, **defaults)
def get_form(self, request, obj=None, **kwargs): """ Returns a Form class for use in the admin add view. This is used by add_view and change_view. """ if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(kwargs.get("exclude", [])) exclude.extend(self.get_readonly_fields(request, obj)) # if exclude is an empty list we pass None to be consistant with the # default on modelform_factory exclude = exclude or None defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) new_form = translation_modelform_factory(self.model, **defaults) current_language = get_language_from_request(request) translation_obj = self.get_translation(request, obj) new_form.base_fields[self.language_field].widget = LanguageWidget( translation_of_obj=obj, translation_obj=translation_obj ) new_form.base_fields[self.language_field].initial = current_language return new_form
def __init__(self, *args, **kwargs): ensure_completely_loaded() if len(Page._feincms_templates) > 4 and "template_key" in self.radio_fields: del (self.radio_fields["template_key"]) super(PageAdmin, self).__init__(*args, **kwargs) # The use of fieldsets makes only fields explicitly listed in there # actually appear in the admin form. However, extensions should not be # aware that there is a fieldsets structure and even less modify it; # we therefore enumerate all of the model's field and forcibly add them # to the last section in the admin. That way, nobody is left behind. from django.contrib.admin.util import flatten_fieldsets present_fields = flatten_fieldsets(self.fieldsets) for f in self.model._meta.fields: if ( not f.name.startswith("_") and not f.name in ("id", "lft", "rght", "tree_id", "level") and not f.auto_created and not f.name in present_fields and f.editable ): self.unknown_fields.append(f.name) if not f.editable: self.readonly_fields.append(f.name)
def get_formset(self, request, obj = None, **kwargs): if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(kwargs.get("exclude", [])) exclude.extend(self.get_readonly_fields(request, obj)) # if exclude is an empty list we use None, since that's the actual # default exclude = exclude or None defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) return reverse_inlineformset_factory(self.parent_model, self.model, self.parent_fk_name, self.formset, **defaults)
def get_form(self, request, obj=None, **kwargs): if 'fields' in kwargs: fields = kwargs.pop('fields') else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(self.get_readonly_fields(request, obj)) if self.exclude is None and hasattr(self.form, '_meta') and self.form._meta.exclude: # Take the custom ModelForm's Meta.exclude into account only if the # ModelAdmin doesn't define its own. exclude.extend(self.form._meta.exclude) # if exclude is an empty list we pass None to be consistent with the # default on modelform_factory exclude = exclude or None defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": partial(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) try: return modelform_factory(self.model, **defaults) except FieldError as e: raise FieldError('%s. Check fields/fieldsets/exclude attributes of class %s.' % (e, self.__class__.__name__))
def get_form(self, request, obj=None, **kwargs): try: if obj is None: form = self.add_form else: form = self.change_form except AttributeError: raise ImproperlyConfigured("%s must have add_form and change_form defined" % self.__name__) if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(kwargs.get("exclude", [])) exclude.extend(self.get_readonly_fields(request, obj)) # if exclude is an empty list we pass None to be consistant with the # default on modelform_factory exclude = exclude or None defaults = { "form": form, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) return modelform_factory(self.model, **defaults)
def get_formset(self, request, obj=None, **kwargs): """ Overwritten ``GenericStackedInline.get_formset`` to restore two options: - Add a ``exclude_unchecked`` field, that allows adding fields like the ``_ptr`` fields. - Restore the ``kwargs`` option. """ if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(self.get_readonly_fields(request, obj)) if self.exclude_unchecked: exclude.extend(self.exclude_unchecked) defaults = { "ct_field": self.ct_field, "fk_field": self.ct_fk_field, "form": self.form, "formfield_callback": curry(self.formfield_for_dbfield, request=request), "formset": self.formset, "extra": self.extra, "can_delete": self.can_delete, "can_order": False, "fields": fields, "max_num": self.max_num, "exclude": exclude } defaults.update(kwargs) # Give the kwargs back return generic_inlineformset_factory(self.model, **defaults)
def get_readonly_fields(self, request, obj=None): if self.declared_fieldsets: return flatten_fieldsets(self.declared_fieldsets) else: return list( set([field.name for field in self.opts.local_fields] + [field.name for field in self.opts.local_many_to_many]))
def test_flatten_fieldsets(self): """ Regression test for #18051 """ fieldsets = ( (None, { 'fields': ('url', 'title', ('content', 'sites')) }), ) self.assertEqual(flatten_fieldsets(fieldsets), ['url', 'title', 'content', 'sites']) fieldsets = ( (None, { 'fields': ('url', 'title', ['content', 'sites']) }), ) self.assertEqual(flatten_fieldsets(fieldsets), ['url', 'title', 'content', 'sites'])
def get_readonly_fields(self, request, obj=None): if self.declared_fieldsets: return flatten_fieldsets(self.declared_fieldsets) else: return list(set( [field.name for field in self.opts.local_fields] + [field.name for field in self.opts.local_many_to_many] ))
def get_form(self, request, obj=None, **kwargs): """ Return a different set of fields if the form is shown in a popup window versus a normal window. To provide better integration with a project manager, which will presumably be managing certain information, we include only the bare necessity of fields in the popup menu. This is pretty much copied from Django source, with a bit to make it work with 1.1 as well as 1.2. Returns a Form class for use in the admin add view. This is used by add_view and change_view. """ from django.contrib.admin.util import flatten_fieldsets from django.forms.models import modelform_factory from django.utils.functional import curry if request.REQUEST.has_key('_popup'): fields = flatten_fieldsets([(None, {'fields': self.popup_fields})]) elif self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(kwargs.get("exclude", [])) if hasattr(self, 'get_readonly_fields'): exclude.extend(self.get_readonly_fields(request, obj)) # if exclude is an empty list we pass None to be consistant with the # default on modelform_factory exclude = exclude or None defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) return modelform_factory(self.model, **defaults)
def _get_all_fields(self, exclude_list=None): if self.declared_fieldsets: result = flatten_fieldsets(self.declared_fieldsets) else: result = list( set([field.name for field in self.opts.local_fields] + [field.name for field in self.opts.local_many_to_many])) return [field for field in result if field not in exclude_list]
def get_readonly_fields(self, *args, **kwargs): if self.declared_fieldsets: return flatten_fieldsets(self.declared_fieldsets) else: return list(set( [field.name for field in self.opts.local_fields] + [field.name for field in self.opts.local_many_to_many] ))
def get_readonly_fields(self, request, obj=None): if request.user.is_superuser: return self.readonly_fields if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = [field.name for field in self.model._meta.fields] return fields
def get_form(self, request, obj=None, **kwargs): defaults = { "form": self.form if not obj else forms.ModelForm, "fields": flatten_fieldsets(self.get_fieldsets(request, obj)), "exclude": self.get_readonly_fields(request, obj), "formfield_callback": partial(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) return modelform_factory(self.model, **defaults)
def _get_all_fields(self, exclude_list=None): if self.declared_fieldsets: result = flatten_fieldsets(self.declared_fieldsets) else: result = list(set( [field.name for field in self.opts.local_fields] + [field.name for field in self.opts.local_many_to_many] )) return [field for field in result if field not in exclude_list]
def get_mass_upload_context(self, request): model = self.model opts = model._meta self.register_newman_variables(request) # To enable admin-specific fields, we need to run the form class # through modelform_factory using curry FormClass = modelform_factory(Photo, form=MassUploadForm, fields=flatten_fieldsets(self.mass_upload_fieldsets), formfield_callback=curry(self.formfield_for_dbfield,request=request) ) context = {} if request.method == 'POST': error_dict = {} # Unfortunately, FLASH uploader sends array data in weird format # so that Django doesn't recognize it as array of values, but # as one string with commas inside. The only way to expect it # and preprocess the values by ourselves. data = dict((key, val) for key, val in request.POST.items()) form = FormClass(data, request.FILES) if form.is_valid(): # To prevent newman from handling our field by common flash editor # we need to use a different mechanism new_object = form.save(commit=False) new_object.image = form.cleaned_data['image_file'] new_object.save() form.save_m2m() context.update({'object': new_object}) else: for e in form.errors: error_dict[u"id_%s" % e] = [ u"%s" % ee for ee in form.errors[e] ] context.update({'error_dict': error_dict}) else: form = FormClass() adminForm = helpers.AdminForm(form, list(self.mass_upload_fieldsets), self.prepopulated_fields) media = self.media + adminForm.media context.update({ 'title': _('Mass upload'), 'adminform': adminForm, 'is_popup': request.REQUEST.has_key('_popup'), 'show_delete': False, 'media': media, 'inline_admin_formsets': [], 'errors': helpers.AdminErrorList(form, ()), 'root_path': self.admin_site.root_path, 'app_label': opts.app_label, 'opts': opts, 'has_change_permission': self.has_change_permission(request, None), 'raw_form': form }) return context
def get_readonly_fields(self, request, obj=None): from django.contrib.admin.util import flatten_fieldsets if not request.user.is_superuser: if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: form = self.get_formset(request, obj).form fields = form.base_fields.keys() return fields return self.readonly_fields
def get_readonly_fields(self, request, obj=None): if self.declared_fieldsets: fieldsets = flatten_fieldsets(self.declared_fieldsets) fieldsets.remove('state') return fieldsets else: return list( set([ field.name for field in self.opts.local_fields if field.name != 'state' ] + [field.name for field in self.opts.local_many_to_many]))
def fields(self): fk = getattr(self.formset, "fk", None) for i, field in enumerate(flatten_fieldsets(self.fieldsets)): if fk and fk.name == field: continue if field in self.readonly_fields: label = label_for_field(field, self.opts.model, self.model_admin) yield (False, forms.forms.pretty_name(label)) else: field = self.formset.form.base_fields[field] yield (field.widget.is_hidden, field.label)
def get_readonly_fields(self, request, obj=None): try: declared_fieldsets = self.declared_fieldsets except AttributeError: declared_fieldsets = False if declared_fieldsets: return flatten_fieldsets(self.declared_fieldsets) else: return list( set([field.name for field in self.opts.local_fields] + [field.name for field in self.opts.local_many_to_many]))
def get_form(self, request, obj=None, **kwargs): """ Use special form during user creation """ defaults = {} if obj is None: defaults.update({ 'form': modelform_factory(self.model, self.add_form), 'fields': flatten_fieldsets(self.add_fieldsets), }) defaults.update(kwargs) return super(BasicUserAdmin, self).get_form(request, obj, **defaults)
def __iter__(self): """ If `fieldset` attribute is not defined we iterate normally. Otherwise we iterate in the order in which fields are defined in `fieldset` attribute. In the later case we return fields as `FieldsetBoundField`. """ if not hasattr(self, 'fieldset'): for field in super(FieldsetFormMixin, self).__iter__(): yield field else: for field in admin_util.flatten_fieldsets(self.fieldset): yield self[field]
def get_form(self, request, obj=None, **kwargs): if 'fields' in kwargs: fields = kwargs.pop('fields') else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(self.get_readonly_fields(request, obj)) if self.exclude is None and hasattr( self.form, '_meta') and self.form._meta.exclude: # Take the custom ModelForm's Meta.exclude into account only if the # ModelAdmin doesn't define its own. exclude.extend(self.form._meta.exclude) # if exclude is an empty list we pass None to be consistent with the # default on modelform_factory exclude = exclude or None if obj and obj.plan.provider == Plan.CLOUDSTACK: if 'offering' in self.fieldsets_change[0][1][ 'fields'] and 'offering' in self.form.declared_fields: del self.form.declared_fields['offering'] else: self.fieldsets_change[0][1]['fields'].append('offering') DatabaseForm.setup_offering_field(form=self.form, db_instance=obj) if obj: if 'disk_offering' in self.fieldsets_change[0][1]['fields']: self.fieldsets_change[0][1]['fields'].remove('disk_offering') self.fieldsets_change[0][1]['fields'].append('disk_offering') DatabaseForm.setup_disk_offering_field(form=self.form, db_instance=obj) defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": partial(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) try: return modelform_factory(self.model, **defaults) except FieldError as e: raise FieldError( '%s. Check fields/fieldsets/exclude attributes of class %s.' % (e, self.__class__.__name__))
def get_form(self, request, obj=None, **kwargs): """ Fra http://code.djangoproject.com/ticket/8387 OBS: Denne kraskjer hardt og brutalt hvis du ikke har en get_fieldsets overridet, siden den orginale get_fieldsets kaller denne """ defaults = { 'fields': flatten_fieldsets(self.get_fieldsets(request, obj)), } defaults.update(kwargs) return super(ArticleAdmin, self).get_form(request, obj, **defaults)
def fields(self): for i, field in enumerate(flatten_fieldsets(self.fieldsets)): if field in self.readonly_fields: yield { 'label': label_for_field(field, self.opts.model, self.opts), 'widget': { 'is_hidden': False }, 'required': False } else: yield self.formset.form.base_fields[field]
def get_form(self, request, obj=None, **kwargs): """ Custom get_form function to returns a revert form class for use in the admin add view. This is used by add_view and change_view. """ from django.db.models.loading import get_model if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(kwargs.get("exclude", [])) exclude.extend(self.get_readonly_fields(request, obj)) # if exclude is an empty list we pass None to be consistant with the # default on modelform_factory exclude = exclude or None defaults = { "form": self.revert_form, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) form = modelform_factory(self.revert_model, **defaults) for key, field in form.base_fields.items(): if isinstance(field.widget, (widgets.AdminAjaxSelectMultipleInputWidget, widgets.CheckboxSelectMultipleCustom)): if hasattr(field.widget, 'model'): model = field.widget.model elif hasattr(field.widget, 'module_name') and hasattr( field.widget, 'app_label'): model = get_model(app_label=app_label, module_name=module_name) related_modeladmin = self.admin_site._registry.get(model) can_add_related = bool( related_modeladmin and related_modeladmin.has_add_permission(request)) field.widget.can_add_related = can_add_related return form
def _get_form_factory_opts(self, request, obj=None, **kwargs): if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(self.get_readonly_fields(request, obj)) if self.exclude is None and hasattr(self.form, '_meta') and self.form._meta.exclude: # Take the custom ModelForm's Meta.exclude into account only if the # ModelAdmin doesn't define its own. exclude.extend(self.form._meta.exclude) # construct the form_opts from declared_fieldsets form_opts = self.app_form_opts.copy() if fields is not None: # put app_name prefixed fields into form_opts for f in fields: if '.' not in f: continue label, name = f.split('.') app_fields = form_opts.setdefault(label, {}).setdefault('fields', []) if name not in app_fields: app_fields.append(name) # .. and remove them from fields for the model form fields = [f for f in fields if '.' not in f] # do the same for exclude for f in exclude: if '.' not in f: continue label, name = f.split('.') app_fields = form_opts.setdefault(label, {}).setdefault('exclude', []) if name not in app_fields: app_fields.append(name) exclude = [f for f in exclude if '.' not in f] # if exclude is an empty list we pass None to be consistant with the # default on modelform_factory exclude = exclude or None defaults = { "form": self.form, "multiform": self.multiform, "form_opts": form_opts, "fields": fields, "exclude": exclude, "formfield_callback": partial(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) return defaults
def test_construction(self): fieldsets = [ changetracking_fieldset, titles_fieldset, publishing_fieldset, date_publishing_fieldset, seo_fieldset, ] expecting = ['created', 'modified', 'title', 'menu_title', 'is_published', 'publish_on', 'unpublish_on', 'meta_title', 'meta_description', 'meta_keywords'] fields = flatten_fieldsets(fieldsets) self.assertEqual(fields, expecting)
def get_form(self, *args, **kwargs): """ Get form for use in admin add/change view. Ensures that team fields are included in form, even when fieldsets are explicitly specified and don't include the team fieldset (because it is automatically added by ``get_fieldsets``). """ if self.declared_fieldsets: kwargs["fields"] = flatten_fieldsets( self.declared_fieldsets) + ["has_team", "own_team"] return super(TeamModelAdmin, self).get_form(*args, **kwargs)
def invite_user(self, request): """Sends an invitation email with a login token.""" # Check for add and change permission. has_add_permission = self.has_add_permission(request) has_change_permission = self.has_change_permission(request) if not has_add_permission or not has_change_permission: raise PermissionDenied # Process the form. InviteForm = self.get_form(request, form = self.invite_form, fields = flatten_fieldsets(self.invite_fieldsets), ) if request.method == "POST": form = InviteForm(request.POST) if form.is_valid(): # Save the user, marked as inactive. user = form.save(commit=False) user.is_active = False user.is_staff = True user.save() form.save_m2m() # Send an invitation email. self.do_send_invitation_email(request, user) # Message the user. self.message_user(request, "An invitation email has been sent to {email}.".format( email = user.email, )) # Redirect as appropriate. return super(UserAdminBase, self).response_add(request, user) # Using the superclass to avoid the built in munging of the add response. else: form = InviteForm() # Create the admin form. admin_form = admin.helpers.AdminForm(form, self.invite_fieldsets, {}) # Render the template. media = self.media + admin_form.media return render(request, self.invite_form_template, { "title": "Invite user", "opts": self.model._meta, "form": form, "adminform": admin_form, "media": media, "add": True, "change": False, "is_popup": False, "save_as": self.save_as, "has_add_permission": has_add_permission, "has_change_permission": has_change_permission, "has_delete_permission": self.has_delete_permission(request), "show_delete": False, })
def fields(self): fk = getattr(self.formset, "fk", None) for i, field in enumerate(flatten_fieldsets(self.fieldsets)): if fk and fk.name == field: continue if field in self.readonly_fields: yield { 'label': label_for_field(field, self.opts.model, self.opts), 'widget': { 'is_hidden': False }, 'required': False } else: yield self.formset.form.base_fields[field]
def get_form(self, request, obj=None, **kwargs): """ Returns a Form class for use in the admin add view. This is used by add_view and change_view. """ if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None defaults = { "form": self.form, "fields": fields, "formfield_callback": self.formfield_for_dbfield, } defaults.update(kwargs) return modelform_factory(self.model, **defaults)
def get_formset(self, request, obj=None, **kwargs): """ Returns a BaseInlineFormSet class for use in admin add/change views. """ if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) # exclude.extend(self.get_readonly_fields(request, obj)) if self.exclude is None and hasattr( self.form, '_meta') and self.form._meta.exclude: # Take the custom ModelForm's Meta.exclude into account only if the # InlineModelAdmin doesn't define its own. exclude.extend(self.form._meta.exclude) # if exclude is an empty list we use None, since that's the actual # default exclude = exclude or None # can_delete = self.can_delete and self.has_delete_permission(request, obj) defaults = { "form": self.form, "formset": self.formset, "fk_name": self.fk_name, "fields": fields, "exclude": exclude, "formfield_callback": partial(self.formfield_for_dbfield, request=request), "extra": self.extra, "max_num": self.max_num, # "can_delete": can_delete, } defaults.update(kwargs) result = genericm2m_inlineformset_factory(self.parent_model, self.model, **defaults) result.content_types = self.content_types result.ct_fk_field = self.ct_fk_field return result