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_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_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):
"""
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):
"""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)
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 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_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 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_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_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):
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_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_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 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
