def _render_admin_template(self,
template_name,
request,
context,
form=None):
# try to wrap and jump through as many hoops as have a determinable shape...
opts = self.model._meta
context_instance = template.RequestContext(
request, current_app=self.admin_site.name)
ctx = {
'is_popup': request.REQUEST.has_key('_popup'),
'root_path': self.admin_site.root_path,
'app_label': opts.app_label,
'opts': opts,
'has_add_permission': self.has_add_permission(request),
'has_change_permission': self.has_change_permission(request),
'has_delete_permission': self.has_delete_permission(request),
}
if form is not None:
adminform = helpers.AdminForm(
form, [(None, {
'fields': form.base_fields.keys()
})], {})
ctx['errors'] = helpers.AdminErrorList(form, [])
ctx['adminform'] = adminform
ctx.update(context)
return render_to_response(template_name,
ctx,
context_instance=context_instance)
def get_object_action_form_context(self, request, obj, form, action):
opts = self.model._meta
admin_form = helpers.AdminForm(
form,
self.get_object_action_fieldsets(request, obj, form, action),
{},
self.get_object_action_readonly_fields(request, obj, action),
model_admin=self,
)
media = self.media + admin_form.media
verbose_name = self.get_object_action_verbose_name(
request, obj, action)
verbose_name_title = self.get_object_action_verbose_name_title(
request, obj, action)
title = '{} {}'.format(
verbose_name_title[0].upper() + verbose_name_title[1:],
opts.verbose_name)
return dict(
self.admin_site.each_context(request),
title=title,
adminform=admin_form,
object_id=obj.pk,
original=obj,
object=obj,
is_popup=False,
to_field=None,
media=media,
inline_admin_formsets=[],
errors=helpers.AdminErrorList(form, []),
preserved_filters=self.get_preserved_filters(request),
object_action_slug=action,
object_action_verbose_name=verbose_name,
)
def change_power_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_change_permission(request, obj):
raise PermissionDenied
ModelForm = PowerArticleForm
form = ModelForm(instance=obj)
if request.method == 'POST':
form = ModelForm(request.POST, request.FILES, instance=obj)
if form.is_valid():
new_object = self.save_form(request, form, change=True)
new_object.is_active = False
self.save_model(request, new_object, form, True)
change_message = self.construct_change_message(
request, form, [])
self.log_change(request, new_object, change_message)
return self.response_change(request, new_object)
fieldsets = ((None, {
'fields': [
('title', 'slug'),
'header',
'content',
'upload',
]
}), )
adminForm = helpers.AdminForm(form,
list(fieldsets), {'slug': ('title', )},
[],
model_admin=self)
media = self.media + adminForm.media
context = {
'title': u'Editar %s' % obj,
'adminform': adminForm,
'object_id': object_id,
'original': obj,
'is_popup': "_popup" in request.REQUEST,
'media': media,
'show_delete': False,
'inline_admin_formsets': [],
'errors': helpers.AdminErrorList(form, []),
'app_label': opts.app_label,
}
context.update(extra_context or {})
return self.render_change_form(request,
context,
form_url=form_url,
add=True)
def _edit_resource(self, request):
form_class = self._get_edit_form_class()
if request.method == 'POST':
form = form_class(request,
request.POST,
request.FILES,
instance=request.resource)
if form.is_valid():
form.save()
return self.response_success()
else:
try:
#TODO fero
form.write_down_messages()
except AttributeError as e:
log.warning(
'Refactory needed: calling non-existent write_down_messages on form_class=%s'
% form_class)
pass #don't worry for this exception...
else:
form = form_class(request, instance=request.resource)
try:
#TODO fero
form.write_down_messages()
except AttributeError as e:
log.warning(
'Refactory needed: calling non-existent write_down_messages on form_class=%s'
% form_class)
pass #don't worry for this exception...
fields = form.base_fields.keys()
fieldsets = form_class.Meta.gf_fieldsets
adminForm = helpers.AdminForm(form, fieldsets, {})
context = {
'form': form,
'adminform': adminForm,
'opts': form._meta.model._meta,
'add': False,
'change': True,
'is_popup': False,
'save_as': False,
'save_on_top': False,
'has_add_permission': False,
'has_delete_permission': True,
'has_change_permission': True,
'show_delete': False,
'errors': helpers.AdminErrorList(form, []),
}
template = "html/admin_form.html"
return render_to_response(template,
context,
context_instance=RequestContext(request))
def add_view(self, request, form_url='', extra_context=None):
try:
return super(MpolynomModelAdmin,
self).add_view(request, form_url, extra_context)
except (IntegrityError, DatabaseError) as e:
if (str(e) ==
'UNIQUE constraint failed: search_mpolynom.structure_name'
):
e = '''Structure name already exists! Check if the M-polynomial
already exists in the database.'''
model = self.model
opts = model._meta
formsets = []
inline_instances = self.get_inline_instances(request, None)
form = MpolynomAdminForm(request.POST, request.FILES)
form.is_valid()
# make faked nonfield error
form._errors[NON_FIELD_ERRORS] = form.error_class([e])
# We may handle exception here (just to save indentation)
adminForm = helpers.AdminForm(
form,
list(self.get_fieldsets(request)),
self.get_prepopulated_fields(request),
self.get_readonly_fields(request),
model_admin=self)
media = self.media + adminForm.media
inline_admin_formsets = []
for inline, formset in zip(inline_instances, formsets):
fieldsets = list(inline.get_fieldsets(request))
readonly = list(inline.get_readonly_fields(request))
prepopulated = dict(inline.get_prepopulated_fields(request))
inline_admin_formset = helpers.InlineAdminFormSet(
inline,
formset,
fieldsets,
prepopulated,
readonly,
model_admin=self)
inline_admin_formsets.append(inline_admin_formset)
media = media + inline_admin_formset.media
context = {
'title': _('Add %s') % force_text(opts.verbose_name),
'adminform': adminForm,
'is_popup': IS_POPUP_VAR in request,
'media': media,
'inline_admin_formsets': inline_admin_formsets,
'errors': helpers.AdminErrorList(form, formsets),
'app_label': opts.app_label,
'preserved_filters': self.get_preserved_filters(request),
}
context.update(extra_context or {})
return self.render_change_form(request,
context,
form_url=form_url,
add=True)
def add_power_view(self, request, form_url='', extra_context=None):
model = self.model
opts = model._meta
if not self.has_add_permission(request):
raise PermissionDenied
ModelForm = PowerArticleForm
if request.method == 'POST':
form = ModelForm(request.POST, request.FILES)
if form.is_valid():
new_object = self.save_form(request, form, change=False)
new_object.is_active = False
if request.FILES.get('upload'):
# Salvar imagem, usando a view do ckeditor
from ckeditor.views import upload
url = upload(request).content
new_object.header = u'<img src="%s" style="width: 50px; height: 37px;"/>%s' % (url, new_object.header, )
new_object.content = u'<img src="%s" style="width: 270px; height: 152px; margin: 10px; float: left;"/>%s' % (url, new_object.content, )
# Ajustar html
new_object.header = u'<p>%s</p>' % u"</p><p>".join(new_object.header.split('\n'))
new_object.content = u'<p>%s</p>' % u"</p><p>".join(new_object.content.split('\n'))
self.save_model(request, new_object, form, False)
self.log_addition(request, new_object)
messages.info(request, u'O artigo foi gravado com sucesso e já foi enviado para aprovação.')
form = ModelForm()
else:
form = ModelForm()
fieldsets = (
(None, {
'fields': [('title', 'slug'), 'header', 'content', 'upload', ]
}),
)
adminForm = helpers.AdminForm(form, list(fieldsets), {'slug': ('title',)}, [], model_admin=self)
media = self.media + adminForm.media
context = {
'title': u'Adicionar Artigo',
'adminform': adminForm,
'is_popup': "_popup" in request.REQUEST,
'show_delete': False,
'media': media,
'inline_admin_formsets': [],
'errors': helpers.AdminErrorList(form, []),
'app_label': opts.app_label,
}
context.update(extra_context or {})
return self.render_change_form(request, context, form_url=form_url, add=True)
def _add_resource(self, request):
form_class = self._get_add_form_class()
if request.method == 'POST':
form = form_class(request, request.POST)
if form.is_valid():
form.save()
return self.response_success()
else:
try:
#TODO-not-a-priority fero
form.write_down_messages()
except AttributeError as e:
log.warning(
'Refactory needed: calling non-existent write_down_messages on form_class=%s'
% form_class)
pass #don't worry for this exception...
else:
form = form_class(request)
try:
#TODO-not-a-priority fero
form.write_down_messages()
except AttributeError as e:
log.warning(
'Refactory needed: calling non-existent write_down_messages on form_class=%s'
% form_class)
pass #don't worry for this exception...
fields = form.base_fields.keys()
fieldsets = form_class.Meta.gf_fieldsets
adminForm = helpers.AdminForm(form, fieldsets, {})
context = {
'form': form,
'adminform': adminForm,
'opts': form._meta.model._meta,
'add': True,
'change': False,
'is_popup': False,
'save_as': False,
'save_on_top': False,
'has_add_permission': True,
'has_delete_permission': True,
'has_change_permission': False,
'show_delete': False,
'errors': helpers.AdminErrorList(form, []),
'media': mark_safe(adminForm.media),
}
return render_to_context_response(request, self.TEMPLATE_ADD_FORM,
context)
def add_view(self, request, form_url='', extra_context=None):
"The 'add' admin view for this model."
model = self.model
opts = model._meta
if not self.has_add_permission(request):
raise PermissionDenied
if request.method == 'POST':
form = self.form(request.POST, request.FILES, prefix='profile')
user_form = self.add_user_form(request.POST, prefix='user')
if form.is_valid() and user_form.is_valid():
new_user = user_form.save()
new_profile = form.save(commit=False)
new_profile.user = new_user
new_profile.created_by = request.user
new_profile.save()
return self.response_add(request, new_profile)
else:
user_form = self.add_user_form(prefix='user')
form = self.form(prefix='profile')
adminForm = helpers.AdminForm(form,
list(self.get_fieldsets(request)),
self.prepopulated_fields,
self.get_readonly_fields(request),
model_admin=self)
media = self.media + adminForm.media
userAdminForm = helpers.AdminForm(user_form,
user_form.fieldsets, {},
None,
model_admin=self)
context = {
'title': _('Add %s') % force_unicode(opts.verbose_name),
'adminform': adminForm,
'useradminform': userAdminForm,
'is_popup': "_popup" in request.REQUEST,
'show_delete': False,
'media': mark_safe(media),
'errors': helpers.AdminErrorList(form, {}),
'root_path': self.admin_site.root_path,
'app_label': opts.app_label,
}
context.update(extra_context or {})
return self.render_change_form(request,
context,
form_url=form_url,
add=True)
def permission_detail(self, request, permission, obj=None):
try:
obj = self.get_object(request, permission)
except Permission.MultipleObjectsReturned:
return self._get_obj_multiple_exist_redirect(request, permission)
if obj is None:
return self._get_obj_does_not_exist_redirect(request, self.model._meta, permission)
opts = self.model._meta
adminForm = helpers.AdminForm(
self.get_form(request, obj),
list(self.get_fieldsets(request, obj)),
{},
model_admin=self
)
media = self.media + adminForm.media
if (request.method == 'POST' and
adminForm.form.is_valid() and
self.has_auditor_change_permission(request)):
obj.user_set.set(adminForm.form.cleaned_data['users'])
obj.group_set.set(adminForm.form.cleaned_data['groups'])
return self.response_change(request, obj)
context = {
**self.admin_site.each_context(request),
'adminform': adminForm,
'errors': helpers.AdminErrorList(adminForm.form, []),
'media': media,
'views': get_views(),
'permission': '{}.{}'.format(obj.content_type.app_label, obj.codename),
'opts': opts,
'add': False,
'change': True,
'is_popup': False,
'save_as': self.save_as,
'has_editable_inline_admin_formsets': False,
'has_view_permission': self.has_view_permission(request, obj),
'has_add_permission': self.has_add_permission(request, obj),
'has_change_permission': self.has_auditor_change_permission(request),
'has_delete_permission': self.has_delete_permission(request, obj),
'app_label': opts.app_label,
}
return TemplateResponse(
request, "permissions_auditor/admin/permission_detail.html", context
)
def folder_select(self, request):
files = self.model.objects.filter(pk__in=(
request.POST.getlist("files") or request.GET.getlist("files")))
form = SelectFolderForm(
request.POST if request.method == "POST" else None, files=files)
if form.is_valid():
folder = form.cleaned_data["folder"]
form.cleaned_data["files"].update(folder=folder)
self.message_user(request,
_("The files have been successfully moved."))
return self.redirect_to_folder(request, folder.id)
adminForm = helpers.AdminForm(
form,
[[None, {
"fields": list(form.fields.keys())
}]],
{},
(),
model_admin=self,
)
response = self.render_change_form(
request,
dict(
self.admin_site.each_context(request),
title=_("Move files to folder"),
adminform=adminForm,
inline_admin_formsets=[],
object_id=None,
original=None,
is_popup=False,
media=self.media + adminForm.media,
errors=helpers.AdminErrorList(form, []),
preserve_filters=self.get_preserved_filters(request),
cabinet={"querystring": cabinet_querystring(request)},
),
add=False,
change=False,
form_url=request.get_full_path(),
obj=None,
)
response.template_name = [
"admin/cabinet/folder/change_form.html",
"admin/change_form.html",
]
return response
def add_many_view(self, request, form_url='', extra_context=None):
"The 'add' admin view for this model."
model = self.model
opts = model._meta
if not self.has_add_permission(request):
raise PermissionDenied
ModelForm = self.add_many_form
formsets = []
if request.method == 'POST':
form = ModelForm(request.POST, request.FILES)
if form.is_valid():
object_list = form.save(model)
self.message_user(
request,
_('%(count)d %(verbose_name_plural)s were added successfully.'
) % {
'count': len(object_list),
'verbose_name_plural': str(opts.verbose_name_plural)
})
if self.has_change_permission(request, None):
post_url = '../'
else:
post_url = '../../../'
return HttpResponseRedirect(post_url)
else:
form = ModelForm()
adminForm = helpers.AdminForm(form, self.add_many_fieldsets, {})
media = self.media + adminForm.media
inline_admin_formsets = []
context = {
'title': _('Add multiple %s') % str(opts.verbose_name_plural),
'adminform': adminForm,
'is_popup': '_popup' in request.GET,
'show_delete': False,
'media': mark_safe(media),
'inline_admin_formsets': inline_admin_formsets,
'errors': helpers.AdminErrorList(form, formsets),
'app_label': opts.app_label,
}
if extra_context:
context.update(extra_context)
return self.render_add_many_form(request, context, form_url=form_url)
def prepare_view(self, request, extra_context=None):
model, opts = self.model, self.model._meta
base_model = model.get_base_model()
if not self.has_add_permission(request):
raise PermissionDenied
Form = modelform_factory(base_model, form=self.prepare_form)
form = Form(request.POST or None, initial=request.GET)
if form.is_valid():
tt = form.cleaned_data.get('target_type')
tp = form.cleaned_data.get('target_page', None)
url = self.get_admin_url_for_model(tt.model_class(), 'add')
tail = '?target_type=%s' % tt.id
if tp:
tail += '&target_page=%s' % tp.id
if tt.model_class() is not base_model:
tail += '&_changelist_filters=e%%3D%s' % ERROR_VALUE_FOR_REDIRECT
return redirect(url + tail)
adminForm = helpers.AdminForm(form,
form.Meta.admin_fieldsets, {},
form.Meta.admin_readonly_fields,
model_admin=self)
context = dict(
self.admin_site.each_context(request), **{
'title':
_('Prepare form for %s') % force_str(opts.verbose_name),
'adminform': adminForm,
'opts': opts,
'media': self.media + adminForm.media,
'errors': helpers.AdminErrorList(form, []),
})
context.update(extra_context or {})
request.current_app = self.admin_site.name
return TemplateResponse(
request, self.prepare_template or [
"admin/%s/%s/prepare_form.html" %
(opts.app_label, opts.model_name),
"admin/%s/prepare_form.html" % opts.app_label,
"admin/prepare_form.html"
], context)
def add_view(self, request, form_url='', extra_context=None):
if not self.has_add_permission(request):
raise PermissionDenied
data = None
changelist_filters = request.GET.get('_changelist_filters')
if request.method == 'GET' and changelist_filters is not None:
changelist_filters = dict(parse_qsl(changelist_filters))
if 'provider' in changelist_filters:
data = {'provider': changelist_filters['provider']}
form = AccountCreationForm(
data=request.POST if request.method == 'POST' else data)
if form.is_valid():
info = self.model._meta.app_label, self.model._meta.model_name
preserved_filters = self.get_preserved_filters(request)
request.session[PRESERVED_FILTERS_SESSION_KEY] = preserved_filters
redirect_url = reverse(
'admin:%s_%s_login' % info,
kwargs={'provider': form.cleaned_data['provider']})
return redirect(redirect_url)
fieldsets = ((None, {'fields': ('provider', )}), )
adminForm = helpers.AdminForm(form,
list(fieldsets), {},
model_admin=self)
media = self.media + adminForm.media
context = dict(
adminform=adminForm,
is_popup=IS_POPUP_VAR in request.GET,
media=media,
errors=helpers.AdminErrorList(form, ()),
preserved_filters=self.get_preserved_filters(request),
)
context.update(extra_context or {})
return self.render_change_form(request,
context,
add=True,
change=False,
form_url=form_url)
def get_admin_helpers(self,
form,
fields: Iterable[str] = None,
fieldsets=None):
if fieldsets is None:
fieldsets = [(None, {"fields": list(fields)})]
admin_form = helpers.AdminForm(
form=form,
fieldsets=fieldsets,
model_admin=self.kwargs["model_admin"],
prepopulated_fields={},
)
return {
"adminform": admin_form,
"errors": helpers.AdminErrorList(form, []),
"media": self.kwargs["model_admin"].media + admin_form.media,
}
def response_change(self, request, obj):
#####
## Override response_change to ensure that the metadata is valid before
## proceeding with the normal action
#####
# If there is no metadata form, behave as normal
metadata_form_class = self.get_metadata_form_class(request, obj)
# If there is no metadata form, behave as normal
if not metadata_form_class:
return super().response_change(request, obj)
if '_has_metadata' in request.POST:
# If the submit supposedly has metadata, validate it
# If the metadata is valid (and hence has been saved), behave as normal
metadata_form = metadata_form_class(data = request.POST, prefix = 'metadata')
if metadata_form.is_valid():
return super().response_change(request, obj)
#######
## If metadata is invalid, we essentially need to replicate part of
## changeform_view to re-display the form
#######
parent_form_class = self.get_form(request)
parent_form = parent_form_class(request.POST, request.FILES, instance = obj)
admin_form = helpers.AdminForm(
parent_form,
list(self.get_fieldsets(request, obj)),
self.get_prepopulated_fields(request, obj),
self.get_readonly_fields(request, obj),
model_admin = self
)
media = self.media + admin_form.media
context = dict(self.admin_site.each_context(request),
title = 'Change {}'.format(force_text(self.model._meta.verbose_name)),
adminform = admin_form,
object_id = obj.pk,
original = obj,
is_popup = ("_popup" in request.POST or "_popup" in request.GET),
to_field = request.POST.get("_to_field", request.GET.get("_to_field")),
media = media,
inline_admin_formsets = [],
errors = helpers.AdminErrorList(parent_form, []),
preserved_filters = self.get_preserved_filters(request),
)
return self.render_change_form(request, context, add = False, change = True, obj = obj)
def get_change_view_context(self, request, object_id):
model = self.model
opts = model._meta
obj = self.get_change_view_object(object_id)
formsets, form = self.get_change_view_formsets(request, obj)
adminForm = helpers.AdminForm(form, self.get_fieldsets(request, obj), self.prepopulated_fields)
media = self.media + adminForm.media
inline_admin_formsets, media = self.get_change_view_inline_formsets(request, obj, formsets, media)
error_dict = {}
if not form.is_valid():
for e in form.errors:
error_dict[u"id_%s" % e] = [ u"%s" % ee for ee in form.errors[e] ]
prefixes = {}
for formset in formsets:
prefix = formset.get_default_prefix()
prefix_no = prefixes.get(prefix, 0)
prefixes[prefix] = prefix_no + 1
if prefixes[prefix] != 1:
prefix = "%s-%s" % (prefix, prefixes[prefix])
if formset.errors:
for e in formset.errors[prefix_no]:
error_dict[u"id_%s-%d-%s" % (prefix, prefix_no, e)] = [u"%s" % ee for ee in formset.errors[prefix_no][e]]
cx = {
'title': _('Change %s') % force_unicode(opts.verbose_name),
'adminform': adminForm,
'object_id': object_id,
'original': obj,
'is_popup': request.REQUEST.has_key('_popup'),
'media': media,
'inline_admin_formsets': inline_admin_formsets,
'errors': helpers.AdminErrorList(form, formsets),
'error_dict': error_dict,
'root_path': self.admin_site.root_path,
'app_label': opts.app_label,
}
# raw fields added
cx['raw_form'] = form
return cx
def __change_password(self, request):
user = self.resource.user
if request.method == 'POST':
form = self.change_password_form(user, request.POST)
if form.is_valid():
new_user = form.save()
msg = _('Password changed successfully.')
messages.success(request, msg)
return self.response_success()
else:
form = self.change_password_form(user)
fields = form.base_fields.keys()
fieldsets = [(None, {'fields': form.base_fields.keys()})]
adminForm = helpers.AdminForm(form, fieldsets, {})
context = {
'title': _('Change password: %s') % escape(user.username),
'form': form,
'adminform': adminForm,
'opts': user.__class__._meta,
'add': False,
'change': True,
'is_popup': False,
'save_as': False,
'save_on_top': False,
'has_add_permission': False,
'has_delete_permission': False,
'has_change_permission': True,
'show_delete': False,
'errors': helpers.AdminErrorList(form, []),
}
return render_to_context_response(
request,
#'admin/auth/user/change_password.html',
"html/admin_form.html",
context)
def render_action_form(self, request, form, *, title, obj):
adminForm = helpers.AdminForm(
form,
[(None, {
"fields": form.fields.keys()
})], # list(self.get_fieldsets(request, obj)),
{}, # self.get_prepopulated_fields(request, obj),
(), # self.get_readonly_fields(request, obj),
model_admin=self,
)
media = self.media + adminForm.media
context = dict(
self.admin_site.each_context(request),
title=title,
object_id=obj.pk,
original=obj,
adminform=adminForm,
errors=helpers.AdminErrorList(form, ()),
preserved_filters=self.get_preserved_filters(request),
media=media,
is_popup=False,
inline_admin_formsets=[],
save_as_new=False,
show_save_and_add_another=False,
show_save_and_continue=False,
show_delete=False,
)
response = self.render_change_form(request,
context,
add=False,
change=True,
obj=obj)
# Suppress the rendering of the "save and add another" button.
response.context_data["has_add_permission"] = False
return response
def changeform_view(self,
request,
object_id=None,
form_url='',
extra_context=None):
"""
Overriding the changeform view of ModelAdmin to allow the form view to be displayed
when the user only has view permissions.
In this case, the form view will be displayed in readonly mode and without action buttons
"""
to_field = request.POST.get(TO_FIELD_VAR,
request.GET.get(TO_FIELD_VAR))
if to_field and not self.to_field_allowed(request, to_field):
raise DisallowedModelAdminToField(
"The field %s cannot be referenced." % to_field)
model = self.model
opts = model._meta
add = object_id is None
if add:
if not self.has_add_permission(request):
raise PermissionDenied
obj = None
else:
obj = self.get_object(request, unquote(object_id), to_field)
if not self.has_change_permission(
request, obj) and not self.has_view_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)
})
if request.method == 'POST' and "_saveasnew" in request.POST:
return self.add_view(
request,
form_url=reverse('admin:%s_%s_add' %
(opts.app_label, opts.model_name),
current_app=self.admin_site.name))
ModelForm = self.get_form(request, obj)
# do not save the change if I'm not allowed to:
if request.method == 'POST' and self.has_change_permission(
request, obj):
form = ModelForm(request.POST, request.FILES, instance=obj)
if form.is_valid():
form_validated = True
new_object = self.save_form(request, form, change=not add)
else:
form_validated = False
new_object = form.instance
formsets, inline_instances = self._create_formsets(request,
new_object,
change=not add)
if all_valid(formsets) and form_validated:
self.save_model(request, new_object, form, not add)
self.save_related(request, form, formsets, not add)
if add:
self.log_addition(request, new_object)
return self.response_add(request, new_object)
else:
change_message = self.construct_change_message(
request, form, formsets)
self.log_change(request, new_object, change_message)
return self.response_change(request, new_object)
else:
if add:
initial = self.get_changeform_initial_data(request)
form = ModelForm(initial=initial)
formsets, inline_instances = self._create_formsets(
request, self.model(), change=False)
else:
form = ModelForm(instance=obj)
formsets, inline_instances = self._create_formsets(request,
obj,
change=True)
adminForm = helpers.AdminForm(form,
list(self.get_fieldsets(request, obj)),
self.get_prepopulated_fields(
request, obj),
self.get_readonly_fields(request, obj),
model_admin=self)
media = self.media + adminForm.media
inline_formsets = self.get_inline_formsets(request, formsets,
inline_instances, obj)
for inline_formset in inline_formsets:
media = media + inline_formset.media
context = dict(
self.admin_site.each_context(request),
title=(_('Add %s') if add else _('Change %s')) %
force_text(opts.verbose_name),
adminform=adminForm,
object_id=object_id,
original=obj,
is_popup=(IS_POPUP_VAR in request.POST
or IS_POPUP_VAR in request.GET),
to_field=to_field,
media=media,
inline_admin_formsets=inline_formsets,
errors=helpers.AdminErrorList(form, formsets),
preserved_filters=self.get_preserved_filters(request),
)
context.update(extra_context or {})
return self.render_change_form(request,
context,
add=add,
change=not add,
obj=obj,
form_url=form_url)
def render_revision_form(self, request, obj, version, context, revert=False, recover=False):
"""Renders the object revision form."""
model = self.model
opts = model._meta
object_id = obj.pk
# Generate the model form.
ModelForm = self.get_form(request, obj)
formsets = []
if request.method == "POST":
# This section is copied directly from the model admin change view
# method. Maybe one day there will be a hook for doing this better.
form = ModelForm(request.POST, request.FILES, instance=obj, initial=self.get_revision_form_data(request, obj, version))
if form.is_valid():
form_validated = True
new_object = self.save_form(request, form, change=True)
# HACK: If the value of a file field is None, remove the file from the model.
for field in new_object._meta.fields:
if isinstance(field, models.FileField) and form.cleaned_data[field.name] is None:
setattr(new_object, field.name, None)
else:
form_validated = False
new_object = obj
prefixes = {}
for FormSet, inline in zip(self.get_formsets(request, new_object),
self.inline_instances):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(request.POST, request.FILES,
instance=new_object, prefix=prefix,
queryset=inline.queryset(request))
# Hack the formset to stuff in the new data.
related_versions = self.get_related_versions(obj, version, FormSet)
formset.related_versions = related_versions
new_forms = formset.forms[:len(related_versions)]
for formset_form in formset.forms[len(related_versions):]:
if formset_form.fields["DELETE"].clean(formset_form._raw_value("DELETE")):
new_forms.append(formset_form)
formset.forms = new_forms
def total_form_count_hack(count):
return lambda: count
formset.total_form_count = total_form_count_hack(len(new_forms))
# Add this hacked formset to the form.
formsets.append(formset)
if all_valid(formsets) and form_validated:
self.save_model(request, new_object, form, change=True)
form.save_m2m()
for formset in formsets:
# HACK: If the value of a file field is None, remove the file from the model.
related_objects = formset.save(commit=False)
for related_obj, related_form in zip(related_objects, formset.saved_forms):
for field in related_obj._meta.fields:
if isinstance(field, models.FileField) and related_form._raw_value(field.name) is None:
related_info = formset.related_versions.get(unicode(related_obj.pk))
if related_info:
setattr(related_obj, field.name, related_info.field_dict[field.name])
related_obj.save()
formset.save_m2m()
change_message = _(u"Reverted to previous version, saved on %(datetime)s") % {"datetime": format(version.revision.date_created, _(settings.DATETIME_FORMAT))}
self.log_change(request, new_object, change_message)
self.message_user(request, _(u'The %(model)s "%(name)s" was reverted successfully. You may edit it again below.') % {"model": force_unicode(opts.verbose_name), "name": unicode(obj)})
# Redirect to the model change form.
if revert:
return HttpResponseRedirect("../../")
elif recover:
return HttpResponseRedirect("../../%s/" % object_id)
else:
assert False
else:
# This is a mutated version of the code in the standard model admin
# change_view. Once again, a hook for this kind of functionality
# would be nice. Unfortunately, it results in doubling the number
# of queries required to construct the formets.
form = ModelForm(instance=obj, initial=self.get_revision_form_data(request, obj, version))
prefixes = {}
for FormSet, inline in zip(self.get_formsets(request, obj), self.inline_instances):
# This code is standard for creating the formset.
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(instance=obj, prefix=prefix,
queryset=inline.queryset(request))
# Now we hack it to push in the data from the revision!
initial = []
related_versions = self.get_related_versions(obj, version, FormSet)
for related_obj in formset.queryset:
if unicode(related_obj.pk) in related_versions:
initial.append(related_versions.pop(unicode(related_obj.pk)).field_dict)
else:
initial_data = model_to_dict(related_obj)
initial_data["DELETE"] = True
initial.append(initial_data)
for related_version in related_versions.values():
initial_row = related_version.field_dict
pk_name = ContentType.objects.get_for_id(related_version.content_type_id).model_class()._meta.pk.name
del initial_row[pk_name]
initial.append(initial_row)
# Reconstruct the forms with the new revision data.
formset.initial = initial
formset.forms = [formset._construct_form(n) for n in xrange(len(initial))]
def total_form_count_hack(count):
return lambda: count
formset.total_form_count = total_form_count_hack(len(initial))
# Add this hacked formset to the form.
formsets.append(formset)
# Generate admin form helper.
adminForm = helpers.AdminForm(form, self.get_fieldsets(request, obj),
self.prepopulated_fields, self.get_readonly_fields(request, obj),
model_admin=self)
media = self.media + adminForm.media
# Generate formset helpers.
inline_admin_formsets = []
for inline, formset in zip(self.inline_instances, formsets):
fieldsets = list(inline.get_fieldsets(request, obj))
readonly = list(inline.get_readonly_fields(request, obj))
inline_admin_formset = helpers.InlineAdminFormSet(inline, formset,
fieldsets, readonly, model_admin=self)
inline_admin_formsets.append(inline_admin_formset)
media = media + inline_admin_formset.media
# Generate the context.
context.update({"adminform": adminForm,
"object_id": object_id,
"original": obj,
"is_popup": False,
"media": mark_safe(media),
"inline_admin_formsets": inline_admin_formsets,
"errors": helpers.AdminErrorList(form, formsets),
"app_label": opts.app_label,
"add": False,
"change": True,
"revert": revert,
"recover": recover,
"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_file_field": True,
"has_absolute_url": False,
"ordered_objects": opts.get_ordered_objects(),
"form_url": mark_safe(request.path),
"opts": opts,
"content_type_id": ContentType.objects.get_for_model(self.model).id,
"save_as": False,
"save_on_top": self.save_on_top,
"changelist_url": reverse("%s:%s_%s_changelist" % (self.admin_site.name, opts.app_label, opts.module_name)),
"change_url": reverse("%s:%s_%s_change" % (self.admin_site.name, opts.app_label, opts.module_name), args=(obj.pk,)),
"history_url": reverse("%s:%s_%s_history" % (self.admin_site.name, opts.app_label, opts.module_name), args=(obj.pk,)),
"recoverlist_url": reverse("%s:%s_%s_recoverlist" % (self.admin_site.name, opts.app_label, opts.module_name))})
# Render the form.
if revert:
form_template = self.revision_form_template or self._get_template_list("revision_form.html")
elif recover:
form_template = self.recover_form_template or self._get_template_list("recover_form.html")
else:
assert False
return render_to_response(form_template, context, template.RequestContext(request))
def mass_change_view(self,
request,
comma_separated_object_ids,
extra_context=None):
"""The 'mass change' admin view for this model."""
global new_object
model = self.model
opts = model._meta
general_error = None
# Allow model to hide some fields for mass admin
exclude_fields = getattr(self.admin_obj, "massadmin_exclude", ())
queryset = getattr(self.admin_obj, "massadmin_queryset",
self.get_queryset)(request)
object_ids = comma_separated_object_ids.split(',')
object_id = object_ids[0]
try:
obj = queryset.get(pk=unquote(object_id))
except model.DoesNotExist:
obj = None
# TODO It's necessary to check permission and existence for all object
if not self.has_change_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)
formsets = []
errors, errors_list = None, None
mass_changes_fields = request.POST.getlist("_mass_change")
if request.method == 'POST':
# commit only when all forms are valid
try:
with transaction.atomic():
objects_count = 0
changed_count = 0
objects = queryset.filter(pk__in=object_ids)
for obj in objects:
objects_count += 1
form = ModelForm(request.POST,
request.FILES,
instance=obj)
exclude = []
for fieldname, field in list(form.fields.items()):
if fieldname not in mass_changes_fields:
exclude.append(fieldname)
for exclude_fieldname in exclude:
del form.fields[exclude_fieldname]
if form.is_valid():
form_validated = True
new_object = self.save_form(request,
form,
change=True)
else:
form_validated = False
new_object = obj
prefixes = {}
for FormSet in get_formsets(self, request, new_object):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1:
prefix = "%s-%s" % (prefix, prefixes[prefix])
if prefix in mass_changes_fields:
formset = FormSet(request.POST,
request.FILES,
instance=new_object,
prefix=prefix)
formsets.append(formset)
if all_valid(formsets) and form_validated:
# self.admin_obj.save_model(request, new_object, form, change=True)
self.save_model(request,
new_object,
form,
change=True)
form.save_m2m()
for formset in formsets:
self.save_formset(request,
form,
formset,
change=True)
change_message = self.construct_change_message(
request, form, formsets)
self.log_change(request, new_object,
change_message)
changed_count += 1
if changed_count == objects_count:
return self.response_change(request, new_object)
else:
errors = form.errors
errors_list = helpers.AdminErrorList(form, formsets)
# Raise error for rollback transaction in atomic block
raise ValidationError("Not all forms is correct")
except:
general_error = sys.exc_info()[1]
form = ModelForm(instance=obj)
form._errors = errors
prefixes = {}
for FormSet in get_formsets(self, request, obj):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(instance=obj, prefix=prefix)
formsets.append(formset)
adminForm = helpers.AdminForm(form,
self.get_fieldsets(request, obj),
self.prepopulated_fields,
self.get_readonly_fields(request, obj),
model_admin=self.admin_obj)
media = self.media + adminForm.media
# We don't want the user trying to mass change unique fields!
unique_fields = []
try: # Django >= 1.9
fields = model._meta.get_fields()
except:
fields = model._meta.get_all_field_names()
for field_name in fields:
try:
field = model._meta.get_field(field_name)
if field.unique:
unique_fields.append(field_name)
except:
pass
# Buggy! Use at your own risk
#inline_admin_formsets = []
# for inline, formset in zip(self.inline_instances, formsets):
# fieldsets = list(inline.get_fieldsets(request, obj))
# inline_admin_formset = helpers.InlineAdminFormSet(inline, formset, fieldsets)
# inline_admin_formsets.append(inline_admin_formset)
# media = media + inline_admin_formset.media
context = {
'title': _('Change %s') % force_text(opts.verbose_name),
'adminform': adminForm,
'object_id': object_id,
'original': obj,
'unique_fields': unique_fields,
'exclude_fields': exclude_fields,
'is_popup': '_popup' in request.GET or '_popup' in request.POST,
'media': mark_safe(media),
#'inline_admin_formsets': inline_admin_formsets,
'errors': errors_list,
'general_error': general_error,
'app_label': opts.app_label,
'object_ids': comma_separated_object_ids,
'mass_changes_fields': mass_changes_fields,
}
context.update(extra_context or {})
return self.render_mass_change_form(request,
context,
change=True,
obj=obj)
def cb_changeform_view(self, request, *args, **kwargs):
"""
Like a change view in the admin.
"""
view_class = kwargs.get("view_class")
add = kwargs.get("add", True)
obj = kwargs.get("original", None)
object_id = kwargs.get("object_id", None)
title = kwargs.get("title", None)
if hasattr(view_class, "form_class"):
form = view_class.form_class()
else:
form = None
formsets = []
opts = self.model._meta
TO_FIELD_VAR = False
IS_POPUP_VAR = False
change = not True
view_on_site_url = None
form_url = ""
app_label = opts.app_label
if form is not None:
adminForm = helpers.AdminForm(form,
formsets, {},
None,
model_admin=self)
media = self.media + adminForm.media
admin_error_list = helpers.AdminErrorList(form, formsets)
else:
adminForm = None
media = self.media
admin_error_list = None
to_field = request.POST.get(TO_FIELD_VAR,
request.GET.get(TO_FIELD_VAR))
inline_formsets = None
# From ``changeform_view``
if title is None:
title = (_("Bulk add %s") if add else _("Bulk change %s")
) % force_text(opts.verbose_name_plural)
context = dict(
self.admin_site.each_context(request),
title=title,
adminform=adminForm,
object_id=object_id,
original=obj,
is_popup=(IS_POPUP_VAR in request.POST
or IS_POPUP_VAR in request.GET),
to_field=to_field,
media=media,
inline_admin_formsets=inline_formsets,
errors=admin_error_list,
preserved_filters=self.get_preserved_filters(request),
)
# From ``render_change_form``
context.update({
"add":
add,
"change":
change,
"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_file_field":
True, # FIXME - this should check if form or formsets have a FileField,
"has_absolute_url":
view_on_site_url is not None,
"absolute_url":
view_on_site_url,
"form_url":
form_url,
"opts":
opts,
"content_type_id":
get_content_type_for_model(self.model).pk,
"save_as":
self.save_as,
"save_on_top":
self.save_on_top,
"to_field_var":
TO_FIELD_VAR,
"is_popup_var":
IS_POPUP_VAR,
"app_label":
app_label,
"media":
self.media,
})
original_get_context_data = view_class.get_context_data
def _monkey_patch_get_context_data(instance, *args, **kwargs):
data = original_get_context_data(instance, *args, **kwargs)
data.update(context)
return data
view_class.get_context_data = _monkey_patch_get_context_data
return view_class.as_view()(request)
def editpermissions_index_view(self, request, forum_id=None):
"""
Display a form to select a user or a group in order to edit its
permissions for the considered forum.
"""
forum = get_object_or_404(Forum, pk=forum_id) if forum_id \
else None
# Set up the context
context = self.get_forum_perms_base_context(request, forum)
context['forum'] = forum
context['title'] = _('Forum permissions') if forum \
else _('Global forum permissions')
# Handles "copy permission from" form
permissions_copied = False
if forum and request.method == 'POST':
forum_form = PickForumForm(request.POST)
if forum_form.is_valid() and forum_form.cleaned_data['forum']:
self._copy_forum_permissions(forum_form.cleaned_data['forum'], forum)
self.message_user(request, _('Permissions successfully copied'))
permissions_copied = True
context['forum_form'] = forum_form
elif forum:
context['forum_form'] = PickForumForm()
# Handles user or group selection
if request.method == 'POST' and not permissions_copied:
user_form = PickUserForm(request.POST, admin_site=self.admin_site)
group_form = PickGroupForm(request.POST, admin_site=self.admin_site)
if user_form.is_valid() and group_form.is_valid():
user = user_form.cleaned_data.get('user', None) \
if user_form.cleaned_data else None
anonymous_user = user_form.cleaned_data.get('anonymous_user', None) \
if user_form.cleaned_data else None
group = group_form.cleaned_data.get('group', None) \
if group_form.cleaned_data else None
if not user and not anonymous_user and not group:
user_form._errors[NON_FIELD_ERRORS] = user_form.error_class(
[_('Choose either a user ID, a group ID or the anonymous user'), ])
elif user:
# Redirect to user
url_kwargs = {'forum_id': forum.id, 'user_id': user.id} if forum \
else {'user_id': user.id}
return redirect(reverse(
'admin:forum_forum_editpermission_user', kwargs=url_kwargs))
elif anonymous_user:
# Redirect to anonymous user
url_kwargs = {'forum_id': forum.id} if forum else {}
return redirect(reverse(
'admin:forum_forum_editpermission_anonymous_user', kwargs=url_kwargs))
elif group:
# Redirect to group
url_kwargs = {'forum_id': forum.id, 'group_id': group.id} if forum \
else {'group_id': group.id}
return redirect(reverse(
'admin:forum_forum_editpermission_group', kwargs=url_kwargs))
context['user_errors'] = helpers.AdminErrorList(user_form, [])
context['group_errors'] = helpers.AdminErrorList(group_form, [])
else:
user_form = PickUserForm(admin_site=self.admin_site)
group_form = PickGroupForm(admin_site=self.admin_site)
context['user_form'] = user_form
context['group_form'] = group_form
return render(
request, self.editpermissions_index_view_template_name, context)
def change_view(self, request, object_id, form_url='', extra_context=None):
"The 'change' admin view for this model."
model = self.model
opts = model._meta
obj = self.get_object(request, unquote(object_id))
if not self.has_change_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)
})
if request.method == 'POST' and "_saveasnew" in request.POST:
return self.add_view(
request,
form_url=reverse('admin:%s_%s_add' %
(opts.app_label, opts.module_name),
current_app=self.admin_site.name))
ModelForm = self.get_form(request, obj)
formsets = []
inline_instances = self.get_inline_instances(request, obj)
if request.method == 'POST':
form = ModelForm(request.POST, request.FILES, instance=obj)
if form.is_valid():
form_validated = True
new_object = self.save_form(request, form, change=True)
else:
form_validated = False
new_object = obj
prefixes = {}
for FormSet, inline in self.get_formsets_with_inlines(
request, new_object):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1 or not prefix:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(
request.POST,
request.FILES,
instance=new_object,
prefix=prefix,
queryset=inline.get_queryset(request),
)
formsets.append(formset)
if hasattr(inline, 'inlines') and inline.inlines:
self.add_nested_inline_formsets(request, inline, formset)
if self.all_valid_with_nesting(formsets) and form_validated:
self.save_model(request, new_object, form, True)
self.save_related(request, form, formsets, True)
change_message = self.construct_change_message(
request, form, formsets)
self.log_change(request, new_object, change_message)
return self.response_change(request, new_object)
else:
form = ModelForm(instance=obj)
prefixes = {}
for FormSet, inline in self.get_formsets_with_inlines(
request, obj):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1 or not prefix:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(instance=obj,
prefix=prefix,
queryset=inline.get_queryset(request))
formsets.append(formset)
if hasattr(inline, 'inlines') and inline.inlines:
self.add_nested_inline_formsets(request, inline, formset)
adminForm = helpers.AdminForm(
form,
self.get_fieldsets(request, obj),
self.get_prepopulated_fields(request, obj),
self.get_readonly_fields(request, obj),
model_admin=self,
)
media = self.media + adminForm.media
inline_admin_formsets = []
for inline, formset in zip(inline_instances, formsets):
fieldsets = list(inline.get_fieldsets(request, obj))
readonly = list(inline.get_readonly_fields(request, obj))
prepopulated = dict(inline.get_prepopulated_fields(request, obj))
inline_admin_formset = helpers.InlineAdminFormSet(
inline,
formset,
fieldsets,
prepopulated,
readonly,
model_admin=self,
)
inline_admin_formsets.append(inline_admin_formset)
media = media + inline_admin_formset.media
if hasattr(inline, 'inlines') and inline.inlines:
extra_media = self.wrap_nested_inline_formsets(
request, inline, formset)
if extra_media:
media += extra_media
context = {
'title': _('Change %s') % force_text(opts.verbose_name),
'adminform': adminForm,
'object_id': object_id,
'original': obj,
'is_popup': "_popup" in request.GET,
'media': media,
'inline_admin_formsets': inline_admin_formsets,
'errors': helpers.AdminErrorList(form, formsets),
'app_label': opts.app_label,
}
context.update(self.admin_site.each_context(request))
context.update(extra_context or {})
return self.render_change_form(request,
context,
change=True,
obj=obj,
form_url=form_url)
def add_view(self, request, form_url='', extra_context=None):
"The 'add' admin view for this model."
model = self.model
opts = model._meta
if not self.has_add_permission(request):
raise PermissionDenied
ModelForm = self.get_form(request)
formsets = []
inline_instances = self.get_inline_instances(request, None)
if request.method == 'POST':
form = ModelForm(request.POST, request.FILES)
if form.is_valid():
new_object = self.save_form(request, form, change=False)
form_validated = True
else:
form_validated = False
new_object = self.model()
prefixes = {}
for FormSet, inline in self.get_formsets_with_inlines(request):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1 or not prefix:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(data=request.POST,
files=request.FILES,
instance=new_object,
save_as_new="_saveasnew" in request.POST,
prefix=prefix,
queryset=inline.get_queryset(request))
formsets.append(formset)
if inline.inlines:
self.add_nested_inline_formsets(request, inline, formset)
if self.all_valid_with_nesting(formsets) and form_validated:
self.save_model(request, new_object, form, False)
self.save_related(request, form, formsets, False)
args = ()
# Provide `add_message` argument to ModelAdmin.log_addition for
# Django 1.9 and up.
if VERSION[:2] >= (1, 9):
add_message = self.construct_change_message(request,
form,
formsets,
add=True)
args = (request, new_object, add_message)
else:
args = (request, new_object)
self.log_addition(*args)
return self.response_add(request, new_object)
else:
# Prepare the dict of initial data from the request.
# We have to special-case M2Ms as a list of comma-separated PKs.
initial = dict(request.GET.items())
for k in initial:
try:
f = opts.get_field(k)
except FieldDoesNotExist:
continue
if isinstance(f, models.ManyToManyField):
initial[k] = initial[k].split(",")
form = ModelForm(initial=initial)
prefixes = {}
for FormSet, inline in self.get_formsets_with_inlines(request):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1 or not prefix:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(instance=self.model(),
prefix=prefix,
queryset=inline.get_queryset(request))
formsets.append(formset)
if hasattr(inline, 'inlines') and inline.inlines:
self.add_nested_inline_formsets(request, inline, formset)
adminForm = helpers.AdminForm(form,
list(self.get_fieldsets(request)),
self.get_prepopulated_fields(request),
self.get_readonly_fields(request),
model_admin=self)
media = self.media + adminForm.media
inline_admin_formsets = []
for inline, formset in zip(inline_instances, formsets):
fieldsets = list(inline.get_fieldsets(request))
readonly = list(inline.get_readonly_fields(request))
prepopulated = dict(inline.get_prepopulated_fields(request))
inline_admin_formset = helpers.InlineAdminFormSet(inline,
formset,
fieldsets,
prepopulated,
readonly,
model_admin=self)
inline_admin_formsets.append(inline_admin_formset)
media = media + inline_admin_formset.media
if hasattr(inline, 'inlines') and inline.inlines:
extra_media = self.wrap_nested_inline_formsets(
request, inline, formset)
if extra_media:
media += extra_media
context = {
'title': _('Add %s') % force_text(opts.verbose_name),
'adminform': adminForm,
'is_popup': "_popup" in request.GET,
'show_delete': False,
'media': media,
'inline_admin_formsets': inline_admin_formsets,
'errors': helpers.AdminErrorList(form, formsets),
'app_label': opts.app_label,
}
context.update(self.admin_site.each_context(request))
context.update(extra_context or {})
return self.render_change_form(request,
context,
form_url=form_url,
add=True)
def _changeform_view(self, request, object_id, form_url, extra_context):
to_field = request.POST.get(TO_FIELD_VAR,
request.GET.get(TO_FIELD_VAR))
if to_field and not self.to_field_allowed(request, to_field):
raise DisallowedModelAdminToField(
"The field %s cannot be referenced." % to_field)
model = self.model
opts = model._meta
if request.method == 'POST' and '_saveasnew' in request.POST:
object_id = None
add = object_id is None
if add:
if not self.has_add_permission(request):
raise PermissionDenied
obj = None
else:
obj = self.get_object(request, unquote(object_id), to_field)
if not self.has_change_permission(request, obj):
raise PermissionDenied
if obj is None:
return self._get_obj_does_not_exist_redirect(
request, opts, object_id)
ModelForm = self.get_form(request, obj)
if request.method == 'POST':
form = ModelForm(request.POST, request.FILES, instance=obj)
if form.is_valid():
form_validated = True
new_object = self.save_form(request, form, change=not add)
else:
form_validated = False
new_object = form.instance
formsets, inline_instances = self._create_formsets(request,
new_object,
change=not add)
if all_valid(formsets) and form_validated:
self.save_model(request, new_object, form, not add)
self.save_related(request, form, formsets, not add)
change_message = self.construct_change_message(
request, form, formsets, add)
if add:
self.log_addition(request, new_object, change_message)
return self.response_add(request, new_object)
else:
self.log_change(request, new_object, change_message)
return self.response_change(request, new_object)
else:
form_validated = False
else:
if add:
initial = self.get_changeform_initial_data(request)
form = ModelForm(initial=initial)
formsets, inline_instances = self._create_formsets(
request, form.instance, change=False)
else:
form = ModelForm(instance=obj, initial=self.choice_field_value)
formsets, inline_instances = self._create_formsets(request,
obj,
change=True)
adminForm = helpers.AdminForm(form,
list(self.get_fieldsets(request, obj)),
self.get_prepopulated_fields(
request, obj),
self.get_readonly_fields(request, obj),
model_admin=self)
media = self.media + adminForm.media
inline_formsets = self.get_inline_formsets(request, formsets,
inline_instances, obj)
for inline_formset in inline_formsets:
media = media + inline_formset.media
context = dict(
self.admin_site.each_context(request),
title=(_('Add %s') if add else _('Change %s')) % opts.verbose_name,
adminform=adminForm,
object_id=object_id,
original=obj,
is_popup=(IS_POPUP_VAR in request.POST
or IS_POPUP_VAR in request.GET),
to_field=to_field,
media=media,
inline_admin_formsets=inline_formsets,
errors=helpers.AdminErrorList(form, formsets),
preserved_filters=self.get_preserved_filters(request),
)
# Hide the "Save" and "Save and continue" buttons if "Save as New" was
# previously chosen to prevent the interface from getting confusing.
if request.method == 'POST' and not form_validated and "_saveasnew" in request.POST:
context['show_save'] = False
context['show_save_and_continue'] = False
# Use the change template instead of the add template.
add = False
context.update(extra_context or {})
return self.render_change_form(request,
context,
add=add,
change=not add,
obj=obj,
form_url=form_url)
def _changeform_view(self, request, object_id, form_url, extra_context):
"""
A copy of original django method with 4 tricks
1. Calls whole_changeform_validation
2. Calls pre_save() before saving
3. Calls post_save() after saving
4. emits the signal changeform_saved signal
:param request:
:param object_id:
:param form_url:
:param extra_context:
:return:
"""
to_field = request.POST.get(TO_FIELD_VAR,
request.GET.get(TO_FIELD_VAR))
if to_field and not self.to_field_allowed(request, to_field):
raise DisallowedModelAdminToField(
"The field %s cannot be referenced." % to_field)
model = self.model
opts = model._meta
if request.method == 'POST' and '_saveasnew' in request.POST:
object_id = None
add = object_id is None
if add:
if not self.has_add_permission(request):
raise PermissionDenied
obj = None
else:
obj = self.get_object(request, unquote(object_id), to_field)
if not self.has_view_or_change_permission(request, obj):
raise PermissionDenied
if obj is None:
return self._get_obj_does_not_exist_redirect(
request, opts, object_id)
ModelForm = self.get_form(request, obj, change=not add)
if request.method == 'POST':
form = ModelForm(request.POST, request.FILES, instance=obj)
form_validated = form.is_valid()
if form_validated:
new_object = self.save_form(request, form, change=not add)
else:
new_object = form.instance
formsets, inline_instances = self._create_formsets(request,
new_object,
change=not add)
if all_valid(
formsets
) and form_validated and self.whole_changeform_validation(
request, form, formsets, not add):
self.pre_save(form, formsets, change=not add)
self.save_model(request, new_object, form, not add)
self.save_related(request, form, formsets, not add)
self.post_save(request, new_object, form, formsets, not add)
changeform_saved.send(self.model,
instance=new_object,
created=add)
change_message = self.construct_change_message(
request, form, formsets, add)
if add:
self.log_addition(request, new_object, change_message)
return self.response_add(request, new_object)
else:
self.log_change(request, new_object, change_message)
return self.response_change(request, new_object)
else:
form_validated = False
else:
if add:
initial = self.get_changeform_initial_data(request)
form = ModelForm(initial=initial)
formsets, inline_instances = self._create_formsets(
request, form.instance, change=False)
else:
form = ModelForm(instance=obj)
formsets, inline_instances = self._create_formsets(request,
obj,
change=True)
if not add and not self.has_change_permission(request, obj):
readonly_fields = flatten_fieldsets(
self.get_fieldsets(request, obj))
else:
readonly_fields = self.get_readonly_fields(request, obj)
adminForm = helpers.AdminForm(
form,
list(self.get_fieldsets(request, obj)),
# Clear prepopulated fields on a view-only form to avoid a crash.
self.get_prepopulated_fields(request, obj)
if add or self.has_change_permission(request, obj) else {},
readonly_fields,
model_admin=self)
media = self.media + adminForm.media
inline_formsets = self.get_inline_formsets(request, formsets,
inline_instances, obj)
for inline_formset in inline_formsets:
media = media + inline_formset.media
if add:
title = _('Add %s')
elif self.has_change_permission(request, obj):
title = _('Change %s')
else:
title = _('View %s')
context = {
**self.admin_site.each_context(request),
'title': title % opts.verbose_name,
'adminform': adminForm,
'object_id': object_id,
'original': obj,
'is_popup': IS_POPUP_VAR in request.POST
or IS_POPUP_VAR in request.GET,
'to_field': to_field,
'media': media,
'inline_admin_formsets': inline_formsets,
'errors': helpers.AdminErrorList(form, formsets),
'preserved_filters': self.get_preserved_filters(request),
}
# Hide the "Save" and "Save and continue" buttons if "Save as New" was
# previously chosen to prevent the interface from getting confusing.
if request.method == 'POST' and not form_validated and "_saveasnew" in request.POST:
context['show_save'] = False
context['show_save_and_continue'] = False
# Use the change template instead of the add template.
add = False
context.update(extra_context or {})
return self.render_change_form(request,
context,
add=add,
change=not add,
obj=obj,
form_url=form_url)
def history_form_view(self, request, object_id, version_id):
original_opts = self.model._meta
model = getattr(
self.model,
self.model._meta.simple_history_manager_attribute).model
obj = get_object_or_404(
model, **{
original_opts.pk.attname: object_id,
'history_id': version_id,
}).instance
obj._state.adding = False
if not self.has_change_permission(request, obj):
raise PermissionDenied
formsets = []
form_class = self.get_form(request, obj)
if request.method == 'POST':
form = form_class(request.POST, request.FILES, instance=obj)
if form.is_valid():
new_object = self.save_form(request, form, change=True)
self.save_model(request, new_object, form, change=True)
form.save_m2m()
self.log_change(
request, new_object,
self.construct_change_message(request, form, formsets))
return self.response_change(request, new_object)
else:
form = form_class(instance=obj)
admin_form = helpers.AdminForm(
form,
self.get_fieldsets(request, obj),
self.prepopulated_fields,
self.get_readonly_fields(request, obj),
model_admin=self,
)
try:
model_name = original_opts.model_name
except AttributeError: # Django < 1.7
model_name = original_opts.module_name
url_triplet = self.admin_site.name, original_opts.app_label, model_name
context = {
'title':
_('Revert %s') % force_text(obj),
'adminform':
admin_form,
'object_id':
object_id,
'original':
obj,
'is_popup':
False,
'media':
mark_safe(self.media + admin_form.media),
'errors':
helpers.AdminErrorList(form, formsets),
'app_label':
model._meta.app_label,
'original_opts':
original_opts,
'changelist_url':
reverse('%s:%s_%s_changelist' % url_triplet),
'change_url':
reverse('%s:%s_%s_change' % url_triplet, args=(obj.pk, )),
'history_url':
reverse('%s:%s_%s_history' % url_triplet, args=(obj.pk, )),
# Context variables copied from render_change_form
'add':
False,
'change':
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_file_field':
True,
'has_absolute_url':
False,
'form_url':
'',
'opts':
model._meta,
'content_type_id':
ContentType.objects.get_for_model(self.model).id,
'save_as':
self.save_as,
'save_on_top':
self.save_on_top,
'root_path':
getattr(self.admin_site, 'root_path', None),
}
return render(request,
template_name=self.object_history_form_template,
dictionary=context,
current_app=self.admin_site.name)
def add_view(self, request, form_url='', extra_context=None):
"The 'add' admin view for this model."
model = self.model
opts = model._meta
ModelForm = self.get_form(request)
formsets = []
inline_instances = self.get_inline_instances(request, None)
if request.method == 'POST':
form = ModelForm(request.POST, request.FILES)
if form.is_valid():
new_object = self.save_form(request, form, change=False)
form_validated = True
else:
form_validated = False
new_object = self.model()
prefixes = {}
for FormSet, inline in self.get_formsets_with_inlines(request, new_object):
prefix = FormSet.get_default_prefix()
# check if we're trying to create a new project by copying an existing one. If so
# we ignore location and benchmark inlines
if "_saveasnew" not in request.POST or prefix not in ['benchmarks',
'rsr-location-content_type-object_id']:
# end of add although the following block is indented as a result
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1 or not prefix:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(data=request.POST, files=request.FILES,
instance=new_object,
save_as_new="_saveasnew" in request.POST,
prefix=prefix, queryset=inline.get_queryset(request))
formsets.append(formset)
if self.all_valid_with_nesting(formsets) and form_validated:
self.save_model(request, new_object, form, False)
self.save_related(request, form, formsets, False)
message = self.construct_change_message(
request, form, formsets, add=True
)
self.log_addition(request, new_object, message)
return self.response_add(request, new_object)
else:
# Prepare the dict of initial data from the request.
# We have to special-case M2Ms as a list of comma-separated PKs.
initial = dict(request.GET.items())
for k in initial:
try:
f = opts.get_field(k)
except models.FieldDoesNotExist:
continue
if isinstance(f, models.ManyToManyField):
initial[k] = initial[k].split(",")
form = ModelForm(initial=initial)
prefixes = {}
for FormSet, inline in self.get_formsets_with_inlines(request):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1 or not prefix:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(instance=self.model(), prefix=prefix,
queryset=inline.get_queryset(request))
formsets.append(formset)
adminForm = helpers.AdminForm(form, list(self.get_fieldsets(request)),
self.get_prepopulated_fields(request),
self.get_readonly_fields(request),
model_admin=self)
media = self.media + adminForm.media
inline_admin_formsets = []
for inline, formset in zip(inline_instances, formsets):
fieldsets = list(inline.get_fieldsets(request))
readonly = list(inline.get_readonly_fields(request))
prepopulated = dict(inline.get_prepopulated_fields(request))
inline_admin_formset = helpers.InlineAdminFormSet(
inline, formset, fieldsets, prepopulated, readonly, model_admin=self
)
inline_admin_formsets.append(inline_admin_formset)
media = media + inline_admin_formset.media
context = {
'title': _('Add %s') % force_text(opts.verbose_name),
'adminform': adminForm,
'is_popup': IS_POPUP_VAR in request.POST,
'show_delete': False,
'media': media,
'inline_admin_formsets': inline_admin_formsets,
'errors': helpers.AdminErrorList(form, formsets),
'app_label': opts.app_label,
'preserved_filters': self.get_preserved_filters(request),
}
context.update(extra_context or {})
return self.render_change_form(request, context, form_url=form_url, add=True)
def _changeform_view(self, request, object_id, form_url, extra_context):
add = object_id is None
model = self.model
opts = model._meta
if not self.has_add_permission(request):
raise PermissionDenied
formsets = []
if add:
if not self.has_add_permission(request):
raise PermissionDenied
obj = None
else:
obj = self.get_object(request, unquote(object_id))
if not self.has_view_permission(
request, obj) and not self.has_change_permission(
request, obj):
raise PermissionDenied
if obj is None:
return self._get_obj_does_not_exist_redirect(
request, opts, object_id)
model_form = self.get_form(request, obj=obj, change=not add)
if request.method == 'POST':
form = model_form(request.POST, request.FILES, instance=obj)
form_validated = form.is_valid()
if form_validated:
new_object = self.save_form(request, form, change=not add)
else:
new_object = form.instance
prefixes = {}
for FormSet, inline in self.get_formsets_with_inlines(request):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(data=request.POST,
files=request.FILES,
instance=new_object,
save_as_new="_saveasnew" in request.POST,
prefix=prefix)
formsets.append(formset)
if all_valid(formsets) and form_validated:
# Here is the modified code.
for formset, inline in zip(formsets,
self.get_inline_instances(request)):
if not isinstance(inline, ReverseInlineModelAdmin):
continue
obj_list = formset.save()
obj = obj_list[0] if obj_list else None
setattr(new_object, inline.parent_fk_name, obj)
self.save_model(request, new_object, form, change=not add)
form.save_m2m()
for formset in formsets:
self.save_formset(request, form, formset, change=not add)
# self.log_addition(request, new_object)
return self.response_add(request, new_object)
elif form_validated and _formsets_are_blank(
request, new_object, formsets):
self.save_model(request, new_object, form, change=not add)
return self.response_add(request, new_object)
else:
# Prepare the dict of initial data from the request.
# We have to special-case M2Ms as a list of comma-separated PKs.
initial = dict(request.GET.items())
for k in initial:
try:
f = opts.get_field(k)
except models.FieldDoesNotExist:
continue
if isinstance(f, models.ManyToManyField):
initial[k] = initial[k].split(",")
form = model_form(initial=initial, instance=obj)
prefixes = {}
for FormSet, inline in self.get_formsets_with_inlines(request):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(instance=self.model(), prefix=prefix)
formsets.append(formset)
adminForm = helpers.AdminForm(form, list(self.get_fieldsets(request)),
self.prepopulated_fields)
media = self.media + adminForm.media
inline_admin_formsets = []
for inline, formset in zip(self.get_inline_instances(request),
formsets):
fieldsets = list(inline.get_fieldsets(request))
inline_admin_formset = helpers.InlineAdminFormSet(
inline, formset, fieldsets)
inline_admin_formsets.append(inline_admin_formset)
media = media + inline_admin_formset.media
context = {
'title': _('Add %s') % force_text(opts.verbose_name),
'adminform': adminForm,
# 'is_popup': '_popup' in request.REQUEST,
'is_popup': False,
'show_delete': False,
'media': mark_safe(media),
'inline_admin_formsets': inline_admin_formsets,
'errors': helpers.AdminErrorList(form, formsets),
# 'root_path': self.admin_site.root_path,
'app_label': opts.app_label,
}
context.update(extra_context or {})
return self.render_change_form(request,
context,
form_url=form_url,
add=True)
