def get_formset(self, request, obj=None, **kwargs):
"""Returns a BaseInlineFormSet class for use in admin add/change views."""
if django.VERSION >= (1, 6):
# From v1.6 on, using get_fieldsets is ok, as long as no 'fields'
# argument was given. It allows dynamic fieldsets on admin form.
if "fields" in kwargs:
fields = kwargs.pop("fields")
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
else:
# On previous versions, calling get_fieldsets triggers infinite recursion
# and we should stick to statically declared fieldsets
if self.declared_fieldsets:
fields = flatten_fieldsets(self.declared_fieldsets)
else:
fields = None
exclude = tuple(self.exclude or ()) + tuple(kwargs.pop("exclude", ())) + self.get_readonly_fields(request, obj)
defaults = {
"form": self.get_form(request, obj, fields=fields),
"formset": self.formset,
"fk_name": self.fk_name,
"fields": fields,
"exclude": exclude or None,
"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)
language = self._language(request)
return translatable_inlineformset_factory(language, 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 django.VERSION >= (1, 6):
# From v1.6 on, using get_fieldsets is ok, as long as no 'fields'
# argument was given. It allows dynamic fieldsets on admin form.
if 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
else:
# On previous versions, calling get_fieldsets triggers infinite recursion
# and we should stick to statically declared fieldsets
if self.declared_fieldsets:
fields = flatten_fieldsets(self.declared_fieldsets)
else:
fields = None
exclude = (
tuple(self.exclude or ()) +
tuple(kwargs.pop("exclude", ())) +
self.get_readonly_fields(request, obj)
)
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 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 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 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 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_formset(self, request, obj=None, **kwargs):
"""Returns a BaseInlineFormSet class for use in admin add/change views."""
if django.VERSION >= (1, 6):
# From v1.6 on, using get_fieldsets is ok, as long as no 'fields'
# argument was given. It allows dynamic fieldsets on admin form.
if 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
else:
# On previous versions, calling get_fieldsets triggers infinite recursion
# and we should stick to statically declared fieldsets
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.get_form(request, obj, fields=fields),
#"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)
language = self._language(request)
return translatable_inlineformset_factory(language, self.parent_model,
self.model, **defaults)
def get_form(self, request, obj=None, **kwargs):
self.form = modelform_factory(
self.model,
form=UserChangeForm,
fields=models.Attribute.objects.values_list('name', flat=True))
self.add_form = modelform_factory(
self.model,
form=UserCreationForm,
fields=models.Attribute.objects.filter(required=True).values_list(
'name', flat=True))
if 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
if obj:
qs = models.Attribute.objects.all()
else:
qs = models.Attribute.objects.filter(required=True)
non_model_fields = set([a.name for a in qs]) - set(
['first_name', 'last_name'])
fields = list(set(fields) - set(non_model_fields))
kwargs['fields'] = fields
return super(AuthenticUserAdmin, self).get_form(request,
obj=obj,
**kwargs)
def get_readonly_fields(self, request, obj=None):
if self._changeable_fields(request, obj):
return super(ReadonlyModeMixin, self).get_readonly_fields(request, obj)
readonly_fields = flatten_fieldsets(self.get_fieldsets(request, obj))
return readonly_fields
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 get_readonly_fields(self, request, obj=None):
if request.user.is_superuser:
return self.readonly_fields
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]))
# class CustomFriendsTalkAdmin(admin.AdminSite):
#
# def get_urls(self):
# urls = super(CustomFriendsTalkAdmin, self).get_urls()
# custom_urls = [
# path('admin/', self.admin_view(self.send_talk_view), name="preview"),
# ]
# return urls + custom_urls
#
# def send_talk_view(self, request):
# context = dict(
# self.admin_site.each_contet(request),
#
# )
# return TemplateResponse(request, "kakao/friendstalk_create.html", context)
# class TemplateAdmin(admin.ModelAdmin):
# change_form_template = 'admin/preview_template.html'
#
#
# CustomFriendsTalkAdmin.register(FriendsTalk, TemplateAdmin)
def get_formset(self, request, obj=None, **kwargs):
if 'fields' not in kwargs and self.orderable_field:
kwargs['fields'] = flatten_fieldsets(
self.get_fieldsets(request, obj)) + [self.orderable_field]
return super(SelectiveInlineMixin, self).get_formset(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_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,
"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.model, **defaults)
def test_add_fieldset(self):
"""Asserts returns fieldset with added fields."""
fs = Fieldsets(self.fieldsets)
fs.add_fieldset(section="Hospitalisation",
fields=("field1", "field2", "field3"))
flatten = flatten_fieldsets(fs.fieldsets)
self.assertEqual(flatten[-3:], ["field1", "field2", "field3"])
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_formfields(self, request, unique=False, **kwargs):
field_names = flatten_fieldsets(self.get_fieldsets(request))
readonly_fields = self.get_readonly_fields(request)
opts = self.opts
db_fields = []
for field_name in field_names:
if field_name in readonly_fields:
continue
try:
field = opts.get_field(field_name)
except FieldDoesNotExist:
continue
if not field.editable or (field.unique and not unique):
continue
db_fields.append(field)
form_fields = []
for dbfield in db_fields:
formfield = self.formfield_for_dbfield(dbfield,
request=request,
**kwargs)
if formfield is None:
continue
form_fields.append((dbfield, formfield))
return form_fields
def get_formset(self, request, obj=None, **kwargs):
if 'fields' in kwargs:
fields = kwargs.pop('fields')
elif self.get_fieldsets(request, obj):
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
else:
fields = None
# want to combine exclude arguments - can't do that if they're None
# also, exclude starts as a tuple - need to make it a list
exclude = list(kwargs.get("exclude", []))
exclude_2 = self.exclude or []
# but need exclude to be None if result is an empty list
exclude = exclude.extend(list(exclude_2)) or None
defaults = {
"form": self.form,
"fields": fields,
"exclude": exclude,
"formfield_callback": curry(self.formfield_for_dbfield, request=request),
}
kwargs.update(defaults)
factory = reverse_inlineformset_factory(self.parent_model, self.model, self.parent_fk_name, **kwargs)
if self.parent_model._meta.model_name == 'candidatevideopage' and self.model._meta.model_name == 'videopage':
factory.form.base_fields['teach_item'].initial = obj.related_video_page.teach_item
factory.form.base_fields['video_title'].initial = obj.video_title
factory.form.base_fields['user'].initial = request.user
return factory
def show_view(self, request, object_id, form_url='', extra_context=None):
model = self.model
opts = model._meta
obj = self.get_object(request, unquote(object_id))
if not self.has_show_permission(request, obj):
raise PermissionDenied
if obj is None:
raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % {
'name': force_text(opts.verbose_name), 'key': escape(object_id)})
ModelForm = self.get_form(request, obj)
form = ModelForm(instance=obj)
all_fields = flatten_fieldsets(self.get_fieldsets(request, obj))
adminForm = helpers.AdminForm(
form,
list(self.get_fieldsets(request, obj)),
self.get_prepopulated_fields(request, obj),
readonly_fields=all_fields, # All fields readonly
model_admin=self)
media = self.media + adminForm.media
opts = self.model._meta
formsets, inline_instances = self._create_formsets(request, obj, change=True)
inline_formsets = self.get_show_inline_formsets(request, formsets, inline_instances, obj)
for inline_formset in inline_formsets:
media = media + inline_formset.media
# Show Actions
show_actions = self.get_show_actions(request, obj)
view_on_site_url = self.get_view_on_site_url(obj)
context = dict(
self.admin_site.each_context(request),
show_actions=show_actions,
title=_(u'View {verbose_name}').format(
verbose_name=force_unicode(opts.verbose_name)),
adminform=adminForm,
view_name='show',
object_id=object_id,
original=obj,
is_popup=(IS_POPUP_VAR in request.POST or
IS_POPUP_VAR in request.GET),
media=media,
inline_admin_formsets=inline_formsets,
errors=helpers.AdminErrorList(form, []),
app_label=opts.app_label,
is_show_view=True,
has_add_permission=self.has_add_permission(request),
has_change_permission=self.has_change_permission(request, obj),
has_delete_permission=self.has_delete_permission(request, obj),
has_absolute_url=view_on_site_url is not None,
absolute_url=view_on_site_url,
opts=opts,
)
context.update(extra_context or {})
self.log_show(request, obj)
return TemplateResponse(request, self.get_show_object_template(), context)
def get_formset(self, request, obj=None, **kwargs):
if 'fields' in kwargs:
fields = kwargs.pop('fields')
elif self.get_fieldsets(request, obj):
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
else:
fields = None
# want to combine exclude arguments - can't do that if they're None
# also, exclude starts as a tuple - need to make it a list
exclude = list(kwargs.get("exclude", []))
exclude_2 = self.exclude or []
non_editable_fields = [f for f in self.model._meta.fields if not f.editable]
exclude.extend(list(exclude_2))
exclude.extend(non_editable_fields)
# but need exclude to be None if result is an empty list
exclude = exclude or None
defaults = {
"form": self.form,
"fields": fields,
"exclude": exclude,
"formfield_callback": curry(self.formfield_for_dbfield, request=request),
}
kwargs.update(defaults)
return reverse_inlineformset_factory(self.parent_model,
self.model,
self.parent_fk_name,
**kwargs)
def get_formset(self, request, obj=None, **kwargs):
if 'fields' in kwargs:
fields = kwargs.pop('fields')
elif self.get_fieldsets(request, obj):
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
else:
fields = None
# want to combine exclude arguments - can't do that if they're None
# also, exclude starts as a tuple - need to make it a list
exclude = list(kwargs.get("exclude", []))
exclude_2 = self.exclude or []
non_editable_fields = [
f for f in self.model._meta.fields if not f.editable
]
exclude.extend(list(exclude_2))
exclude.extend(non_editable_fields)
# but need exclude to be None if result is an empty list
exclude = exclude or None
defaults = {
"form":
self.form,
"fields":
fields,
"exclude":
exclude,
"formfield_callback":
curry(self.formfield_for_dbfield, request=request),
}
kwargs.update(defaults)
return reverse_inlineformset_factory(self.parent_model, self.model,
self.parent_fk_name, **kwargs)
def get_formset(self, request, obj=None, **kwargs):
"""Returns a BaseInlineFormSet class for use in admin add/change views."""
if 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
exclude = (tuple(self.exclude or ()) + tuple(kwargs.pop("exclude",
())) +
self.get_readonly_fields(request, obj))
defaults = {
"form":
self.get_form(request, obj, fields=fields),
"formset":
self.formset,
"fk_name":
self.fk_name,
"fields":
fields,
"exclude":
exclude or None,
"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)
language = self._language(request)
return translatable_inlineformset_factory(language, self.parent_model,
self.model, **defaults)
def get_form(self, request, obj=None, **kwargs):
"""Workaround bug http://code.djangoproject.com/ticket/9360."""
return super(PartnerSiteAdmin,
self).get_form(request,
obj,
fields=flatten_fieldsets(
self.get_fieldsets(request, obj)))
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 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
exclude = (tuple(self.exclude or ()) + tuple(kwargs.pop("exclude",
())) +
tuple(self.get_readonly_fields(request, obj) or ()))
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)
if django.VERSION > (2, 1) and 'change' in defaults:
del defaults['change']
return translatable_modelform_factory(language, self.model, **defaults)
def get_formset(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)
# 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':
functools.partial(self.formfield_for_dbfield, request=request),
}
defaults.update(kwargs)
return reverse_inlineformset_factory(self.parent_model, self.model,
self.parent_fk_name, **defaults)
def get_form(self, request, obj=None, **kwargs):
for i in dir(self):
print i
print "@@@@@@@@@@@"
print "!!!", ' |self.form: ', type(self.form)
for i in dir(self.form):
print i
print "!!!", ' |self.form.Meta: ', type(self.form.Meta)
for i in dir(self.form.Meta):
print i
print "!!!", ' |self.form.Meta.fields: ', self.form.Meta.fields
# print "!!!",' |self.formfield_for_choice_field: ',\
# self.formfield_for_choice_field()
# print "!!!",' |self.formfield_for_dbfield: ',\
# type(self.formfield_for_dbfield)
# print "!!!",' |self.formfield_for_foreignkey: ',\
# type(self.formfield_for_foreignkey)
# print "!!!",' |self.formfield_for_manytomany: ',\
# type(self.formfield_for_manytomany)
# print "!!!",' |self.formfield_overrides: ',\
# type(self.formfield_overrides)
# print '!!!', ' self.form ', dir(self.form)
# print '!!!!!!!!', ' self.form ', self.form.declared_fields
# print '!!!!!!!!', ' self.clean ', type(self.form)
kwargs['fields'] = flatten_fieldsets(self.fieldsets)
return super(TestTabAdmin, self).get_form(request, obj, **kwargs)
def fields(self):
fk = getattr(self.formset, "fk", None)
for i, field_name in enumerate(flatten_fieldsets(self.fieldsets)):
if fk and fk.name == field_name:
continue
if field_name in self.readonly_fields:
yield {
'label':
label_for_field(field_name, self.opts.model, self.opts),
'widget': {
'is_hidden': False
},
'required':
False,
'help_text':
help_text_for_field(field_name, self.opts.model),
}
else:
form_field = self.formset.form.base_fields[field_name]
label = form_field.label
if label is None:
label = label_for_field(field_name, self.opts.model,
self.opts)
yield {
'label': label,
'widget': form_field.widget,
'required': form_field.required,
'help_text': form_field.help_text,
}
def get_readonly_fields(self, request, obj=None):
if hasattr(request, '--avoid-get_readonly_fields-recursion--'):
return super(AccessControlMixin, self).get_readonly_fields(request, obj)
if not obj:
return super(AccessControlMixin, self).get_readonly_fields(request, obj)
if not self.has_basic_change_permission(request):
setattr(request, '--avoid-get_readonly_fields-recursion--', True)
own_fields = flatten_fieldsets(self.get_fieldsets(request, obj))
delattr(request, '--avoid-get_readonly_fields-recursion--')
return list_union(super(AccessControlMixin, self).get_readonly_fields(request, obj), own_fields)
if not self.has_basic_change_permission(request, obj):
setattr(request, '--avoid-get_readonly_fields-recursion--', True)
own_fields = flatten_fieldsets(self.get_fieldsets(request, obj))
delattr(request, '--avoid-get_readonly_fields-recursion--')
return list_union(super(AccessControlMixin, self).get_readonly_fields(request, obj), own_fields)
return super(AccessControlMixin, self).get_readonly_fields(request, obj)
def table_header_row(inline_admin_formset):
'''Similar to InlineAdminFormSet.fields but also returns field name
Update the dict returned by InlineAdminFormSet.fields and update it with
additional attributes that we need for adding sorting urls.
'''
formset = inline_admin_formset.formset
query_dict = formset.cl.params.copy()
ordering = query_dict.getlist(formset.order_param, [])
toggle_remove_urls = get_toggle_remove_urls(formset, ordering)
try:
fk_name = formset.fk.name
except AttributeError:
fk_name = None
field_names = [
i for i in flatten_fieldsets(inline_admin_formset.fieldsets)
if i != fk_name
]
fields = []
for field_name, field in zip(field_names, inline_admin_formset.fields()):
try:
urls = toggle_remove_urls[field_name]
except KeyError:
toggle = get_updated_url(formset, None, field_name)
urls = SortingUrl('', toggle, '')
fields.append(SortableField(field_name, field, urls))
return {
'fields': fields,
'formset': formset,
}
def get_formset(self, request, obj=None, **kwargs):
"""Returns a BaseInlineFormSet class for use in admin add/change views."""
if 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
exclude = (
tuple(self.exclude or ()) +
tuple(kwargs.pop("exclude", ())) +
self.get_readonly_fields(request, obj)
)
defaults = {
"form": self.get_form(request, obj, fields=fields),
"formset": self.formset,
"fk_name": self.fk_name,
"fields": fields,
"exclude": exclude or None,
"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)
language = self._language(request)
return translatable_inlineformset_factory(language, self.parent_model, self.model, **defaults)
def fields(self):
fk = getattr(self.formset, "fk", None)
empty_form = self.formset.empty_form
meta_labels = empty_form._meta.labels or {}
meta_help_texts = empty_form._meta.help_texts or {}
for i, field_name in enumerate(flatten_fieldsets(self.fieldsets)):
if fk and fk.name == field_name:
continue
if not self.has_change_permission or field_name in self.readonly_fields:
yield {
'label':
meta_labels.get(field_name)
or label_for_field(field_name, self.opts.model, self.opts),
'widget': {
'is_hidden': False
},
'required':
False,
'help_text':
meta_help_texts.get(field_name)
or help_text_for_field(field_name, self.opts.model),
}
else:
form_field = empty_form.fields[field_name]
label = form_field.label
if label is None:
label = label_for_field(field_name, self.opts.model,
self.opts)
yield {
'label': label,
'widget': form_field.widget,
'required': form_field.required,
'help_text': form_field.help_text,
}
def get_readonly_fields(self, request, obj=None, fields=None):
is_add = obj is None
readonly_fields = list(super().get_readonly_fields(request, obj))
if (is_add and not self.has_add_permission(request)) or \
(not is_add and not self.has_change_permission(request, obj)):
return fields if fields is not None else self.get_list_display(request, False)
readonly_fields_set = set(readonly_fields)
if not is_add:
for field in self.change_view_readonly_fields:
if field not in readonly_fields_set:
readonly_fields_set.add(field)
readonly_fields.append(field)
changeable_fields = self.get_changeable_fields(request, obj)
if changeable_fields is not None:
changeable_fields_set = set(changeable_fields)
declared_fields = self.fieldsets
if declared_fields:
declared_fields = flatten_fieldsets(declared_fields)
else:
declared_fields = [f.name for f in self.opts._get_fields(reverse=False)]
for field in declared_fields:
if field not in changeable_fields_set and field not in readonly_fields_set:
readonly_fields_set.add(field)
readonly_fields.append(field)
return readonly_fields
def fields(self):
fk = getattr(self.formset, "fk", None)
for i, field_name in enumerate(flatten_fieldsets(self.fieldsets)):
if fk and fk.name == field_name:
continue
if field_name in self.readonly_fields:
yield {
'label': label_for_field(field_name, self.opts.model, self.opts),
'widget': {
'is_hidden': False
},
'required': False,
'help_text': help_text_for_field(field_name, self.opts.model),
}
else:
form_field = self.formset.form.base_fields[field_name]
label = form_field.label
if label is None:
label = label_for_field(field_name, self.opts.model, self.opts)
yield {
'label': label,
'widget': form_field.widget,
'required': form_field.required,
'help_text': form_field.help_text,
}
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,
"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.model, **defaults)
def get_readonly_fields(self, request, obj=None):
args = get_func_args(self.has_add_permission)
if 'obj' in args:
has_add_permission = self.has_add_permission(request, obj)
else:
has_add_permission = self.has_add_permission(request)
if obj is None and has_add_permission:
return super().get_readonly_fields(request, obj)
if self.fields or self.fieldsets:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
else:
opts = self.model._meta
sortable_private_fields = [f for f in opts.private_fields if isinstance(f, Field)]
fields = [
field.name for field in
sorted(chain(opts.concrete_fields, sortable_private_fields, opts.many_to_many))
if field.editable and not field.auto_created
]
exclude = self.get_exclude(request, obj)
editable_fields = self.get_editable_fields(request, obj)
return [
field for field in fields
if field not in editable_fields and field not in exclude
]
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),
"instance": obj
}
defaults.update(kwargs)
return reverse_inlineformset_factory(self.parent_model,
self.model,
self.parent_fk_name,
**defaults)
def get_readonly_fields(self, request, obj=None, fields=None):
if obj and self.has_edit_perm(request, obj):
readonly_fields = list(
super(ProxyModelAdmin, self).get_readonly_fields(request, obj))
readonly_fields_set = set(readonly_fields)
for field in self.change_view_readonly_fields:
if field not in readonly_fields_set:
readonly_fields_set.add(field)
readonly_fields.append(field)
editable_fields = self.get_editable_fields(request, obj)
if editable_fields is not None:
editable_fields_set = set(editable_fields)
declared_fields = self.fieldsets
if declared_fields:
declared_fields = flatten_fieldsets(declared_fields)
else:
declared_fields = [f.name for f in self.opts.fields]
for field in declared_fields:
if (field not in editable_fields_set
and field not in readonly_fields_set):
readonly_fields_set.add(field)
readonly_fields.append(field)
return readonly_fields
elif not self.has_edit_perm(request, obj):
return fields if fields is not None else self.get_list_display(
request)
else:
return list(
super(ProxyModelAdmin, self).get_readonly_fields(request, obj))
def fields(self):
fk = getattr(self.formset, "fk", None)
empty_form = self.formset.empty_form
meta_labels = empty_form._meta.labels or {}
meta_help_texts = empty_form._meta.help_texts or {}
for i, field_name in enumerate(flatten_fieldsets(self.fieldsets)):
if fk and fk.name == field_name:
continue
if not self.has_change_permission or field_name in self.readonly_fields:
yield {
'label': meta_labels.get(field_name) or label_for_field(field_name, self.opts.model, self.opts),
'widget': {'is_hidden': False},
'required': False,
'help_text': meta_help_texts.get(field_name) or help_text_for_field(field_name, self.opts.model),
}
else:
form_field = empty_form.fields[field_name]
label = form_field.label
if label is None:
label = label_for_field(field_name, self.opts.model, self.opts)
yield {
'label': label,
'widget': form_field.widget,
'required': form_field.required,
'help_text': form_field.help_text,
}
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 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)
try:
has_view_permission = self.has_view_permission(request)
except AttributeError:
has_view_permission = True
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.
# Using the superclass to avoid the built in munging of the add response.
return super(UserAdminBase, self).response_add(request, user)
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, dict(
self.admin_site.each_context(request),
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,
has_view_permission=has_view_permission,
has_editable_inline_admin_formsets=True,
))
def _get_form_factory_opts(self, request, obj=None, **kwargs):
fieldsets = self.get_fieldsets(request, obj)
if fieldsets:
fields = flatten_fieldsets(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)
if hasattr(forms, 'ALL_FIELDS'):
# Django 1.7
if defaults['fields'] is None and not modelform_defines_fields(defaults['form']):
defaults['fields'] = forms.ALL_FIELDS
return defaults
def polymorphic_child_admin_class_factory(
base_model, bases=None, admin_fields=None, admin_fieldsets=None):
if not (isinstance(bases, tuple) or bases is None):
raise TypeError('`bases` must be tuple.')
if admin_fields and admin_fieldsets:
raise ValueError('`admin_fields` and `admin_fieldsets` cannot be set at the same time.')
admin_parent_class = bases[0] # FIXME: May need refactoring in future!
fields = {
'__module__': base_model.__module__,
}
if admin_parent_class.fields:
parent_admin_fields = flatten(admin_parent_class.fields)
else:
parent_admin_fields = flatten_fieldsets(admin_parent_class.fieldsets)
parent_admin_fields += ['id', 'pk', 'order', 'ordering', ]
inheritor_admin_fields = [item.name for item in base_model._meta.fields]
new_admin_fields = set(filter(
lambda item: not (item.endswith('_ptr') or item.endswith('_ctype')),
set(inheritor_admin_fields) - set(parent_admin_fields)
))
if admin_parent_class.fields:
if admin_fieldsets:
raise ValueError(
'{} does not allow `admin_fieldsets`, please use `admin_fields`.'.format(bases[0].__name__)
)
if admin_fields:
fields['get_fields'] = _get_fields(admin_fields)
else:
fields['get_fields'] = _get_fields(new_admin_fields)
elif admin_parent_class.fieldsets:
if admin_fields:
raise ValueError(
'{} does not allow `admin_fields`, please use `admin_fieldsets`.'.format(bases[0].__name__)
)
if not admin_fieldsets:
admin_fieldsets = (
(base_model.__name__, {
'fields': tuple(new_admin_fields),
}),
)
fields['get_fieldsets'] = _get_fieldsets(admin_fieldsets)
else:
raise NotImplementedError
class_name = '{}ChildAdmin'.format(base_model.__name__)
return type(class_name, bases, fields)
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 _all_fields(self, request, obj=None):
if self.fields:
return self.fields
if self.fieldsets:
return flatten_fieldsets(self.get_fieldsets(request, obj))
fields = [field.name for field in self.opts.local_fields]
if 'id' in fields: fields.remove('id')
return fields
def get_form(self, request, obj=None, **kwargs):
""" Use special form during user creation and prevent from modifying is_active and is_staff for superuser """
if obj is None:
kwargs['form'] = self.add_form
kwargs['fields'] = flatten_fieldsets(self.add_fieldsets)
kwargs['exclude'] = self.add_exclude
self.fieldsets = self.add_fieldsets
self.readonly_fields = ()
else:
kwargs['form'] = self.update_form
kwargs['fields'] = flatten_fieldsets(self.update_fieldsets)
if not obj.is_superuser:
kwargs['exclude'] = self.update_exclude + self.update_readonly_fields
self.readonly_fields = self.update_readonly_fields
else:
self.readonly_fields = kwargs['exclude'] = flatten_fieldsets(self.update_fieldsets)
self.fieldsets = self.update_fieldsets
return super(GenericUserAdmin, self).get_form(request, obj, **kwargs)
def get_readonly_fields(self, request, obj=None):
if obj is None:
return self.readonly_fields
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
def get_readonly_fields(self, request, obj=None):
# untested, this could do:
# readonly_fields = self.model._meta.get_all_field_names()
# borrowed from ModelAdmin:
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
def get_readonly_fields(self, request, obj=None):
if obj is not None and not obj.is_editable():
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]
))
return super(EncounterAdmin, self).get_readonly_fields(request, obj)
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))
excluded = self.get_exclude(request, obj)
exclude = [] if excluded is None else list(excluded)
readonly_fields = self.get_readonly_fields(request, obj)
exclude.extend(readonly_fields)
if excluded 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
new_attrs = OrderedDict(
(f, None) for f in readonly_fields
if f in self.form.declared_fields
)
form = type(self.form.__name__, (self.form,), new_attrs)
try:
model = obj.content_type.model_class()
model_key = model._meta.pk.name
except (AttributeError, ObjectDoesNotExist):
model = self.model.content_type.field.formfield().choices.queryset[0].model_class()
model_key = 'id'
defaults = {
"form": form,
"fields": fields,
"exclude": exclude,
"formfield_callback": partial(self.formfield_for_dbfield, request=request),
"widgets": {
'content_type': ContentTypeSelect,
'object_id': ForeignKeyRawIdWidget(
rel=ManyToOneRel(model_key, model, 'id'),
admin_site=admin.site
)
}
}
defaults.update(kwargs)
if defaults['fields'] is None and not modelform_defines_fields(defaults['form']):
defaults['fields'] = forms.ALL_FIELDS
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):
"""
Use special form during creation
"""
defaults = {}
if obj is None:
defaults.update({
'form': self.add_form,
'fields': flatten_fieldsets(self.add_fieldsets),
})
defaults.update(kwargs)
return super(ObjectDBAdmin, self).get_form(request, obj, **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 django.VERSION >= (1, 6):
# From v1.6 on, using get_fieldsets is ok, as long as no 'fields'
# argument was given. It allows dynamic fieldsets on admin form.
if 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
else:
# On previous versions, calling get_fieldsets triggers infinite recursion
# and we should stick to statically declared fieldsets
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 hasattr(self, "declared_fieldsets") and self.declared_fieldsets:
fields = flatten_fieldsets(self.declared_fieldsets)
elif "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
# 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.get_content_types()
result.ct_fk_field = self.ct_fk_field
return result
def get_readonly_fields(self, request, obj=None):
"""
Make all fields read-only
"""
if not self.all_fields_readonly or (request.user.is_superuser and self.superuser_skips_all_readonly):
return self.readonly_fields
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 batch_upload_response(self, request):
output_fields = flatten_fieldsets(self.fieldsets)
media_file_name = get_media_file_name(self, self.model)
#Disabling exception handling here @olivierdalang's feedback:
# try:
latest_log_entry = LogEntry.objects.filter(action_flag=ADDITION).order_by('-action_time')[0]
ct = ContentType.objects.get_for_id(latest_log_entry.content_type_id)
obj = ct.get_object_for_this_type(pk=latest_log_entry.object_id)
if obj:
object_data = {}
mime = MimeTypes()
media_file = get_media_file(self, self.model, obj)
media_file_url = media_file.url #urllib.pathname2url(media_file.url) #Not sure why i had this, but it's escaping the URL
mime_type = mime.guess_type(media_file_url)
edit_url = reverse('admin:%s_%s_change' %(obj._meta.app_label, obj._meta.model_name), args=[obj.id] )
object_data['media_file_url'] = media_file_url
object_data['media_file_size'] = media_file.size
object_data['media_file_type'] = mime_type[0]
object_data['edit_url'] = mark_safe(edit_url)
field_values = {}
for output_field in output_fields:
value = str(self.get_field_contents(output_field, obj))
label = str(label_for_field(output_field, self.model, self))
field_values[output_field] = {
'label':label,
'value':value
}
object_data['field_values'] = field_values
data = {
"success":True,
"files":[
object_data
]
}
json_dumped = json.dumps(data)
return HttpResponse(json_dumped, content_type='application/json')
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 get_form(self, request, obj=None, **kwargs):
self.form = modelform_factory(self.model, form=UserChangeForm)
self.add_form = modelform_factory(self.model, form=UserCreationForm)
if 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
if obj:
qs = models.Attribute.objects.all()
else:
qs = models.Attribute.objects.filter(required=True)
non_model_fields = [a.name for a in qs]
fields = list(set(fields) - set(non_model_fields))
kwargs['fields'] = fields
return super(AuthenticUserAdmin, self).get_form(request, obj=obj, **kwargs)
def get_show_form(self, request, obj=None, **kwargs):
"""
Returns a Form class for use in the admin show view.
This is used by show_view, and doesn't take into account
the readonly_fields, as all will be shown as readonly by the admin
form.
"""
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)
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
# Remove declared form fields which are in readonly_fields.
readonly_fields = self.get_readonly_fields(request, obj)
new_attrs = OrderedDict(
(f, None) for f in readonly_fields
if f in self.form.declared_fields
)
form = type(self.form.__name__, (self.form,), new_attrs)
defaults = {
"form": form,
"fields": fields,
"exclude": exclude,
"formfield_callback": partial(self.formfield_for_dbfield, request=request),
}
defaults.update(kwargs)
if defaults['fields'] is None and not modelform_defines_fields(defaults['form']):
defaults['fields'] = forms.ALL_FIELDS
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_inline_instances(old_func, self, request, *args):
"""
Skip generic-plus inlines if the field is not in fieldsets.
Failing to do so causes ManagementForm validation errors on save.
"""
inline_instances = old_func(self, request, *args)
fieldsets = flatten_fieldsets(self.get_fieldsets(request))
def skip_inline_instance(inline):
f = getattr(inline, 'field', None)
return isinstance(f, GenericForeignFileField) and f.name not in fieldsets
if isinstance(inline_instances, types.GeneratorType):
return (i for i in inline_instances if not(skip_inline_instance(i)))
else:
return [i for i in inline_instances if not(skip_inline_instance(i))]
def get_form(self, request, obj=None, **kwargs):
"""
Use special form during creation.
Args:
request (Request): Incoming request.
obj (Object, optional): Database object.
"""
defaults = {}
if obj is None:
defaults.update({
'form': self.add_form,
'fields': flatten_fieldsets(self.add_fieldsets),
})
defaults.update(kwargs)
return super(ObjectDBAdmin, self).get_form(request, obj, **defaults)
