def delete_selected_action(self, model_admin, request, qs): objects = UsersTasksValidationAdmin.QSList(qs) if request.POST.get('post'): deletable_objects, model_count, perms_needed, protected = get_deleted_objects( objects, request, model_admin.admin_site) if not protected: res = delete_selected(model_admin, request, objects) for obj in objects: self.on_object_deleted(obj) return res response = delete_selected(model_admin, request, objects) context = response.context_data context['running_tasks'] = self.get_user_task_names() or None return TemplateResponse(request, model_admin.delete_selected_confirmation_template, context)
def delete_selected(self, request, queryset): # We use processed ProblemPackage instances to store orignal package # files. if queryset.filter(status="OK").exists(): messages.error(request, _("Cannot delete a processed Problem Package")) else: return delete_selected(self, request, queryset)
def delete_selected(modeladmin, request, queryset): """ Has to have same name as admin.actions.delete_selected """ related_transactions = helpers.pre_delete_processes(modeladmin, request, queryset) response = actions.delete_selected(modeladmin, request, queryset) if response is None: helpers.post_delete_processes(modeladmin, request, related_transactions) return response
def delete_selected_entity(modeladmin, request, queryset): """ Action de suppression dans l'administration """ queryset._from_admin = True queryset._current_user = request.user return delete_selected(modeladmin, request, queryset)
def view(self, request, extra_context=None): queryset = self.model.objects.all() response = delete_selected(self.modeladmin, request, queryset) if response: return response else: return self.modeladmin.changelist_view(request)
def delete_selected(self, request, queryset): for obj in queryset: if not self.has_delete_permission(request, obj): messages.add_message(request, messages.ERROR, '権限なしまたは提出済のレコードのために、削除できません!') return return actions.delete_selected(self, request, queryset)
def delete_selected_overridden(self, request, queryset): count = 0 pks = [] for obj in queryset: if obj.user.is_owner(obj.organization_id): pks.append(obj.pk) count += 1 # if trying to delete only org users which belong to owners, stop here if count and count == queryset.count(): self.message_user( request, _("Can't delete organization users which belong to owners."), messages.ERROR, ) redirect_url = reverse( f'admin:{self.model._meta.app_label}_organizationuser_changelist' ) return HttpResponseRedirect(redirect_url) # if some org owners' org users were selected if count and count != queryset.count(): queryset = queryset.exclude(pk__in=pks) single_msg = ( f"Can't delete {count} organization user because it " 'belongs to an organization owner.' ) multiple_msg = ( f"Can't delete {count} organization users because they " 'belong to some organization owners.' ) self.message_user( request, ngettext(single_msg, multiple_msg, count), messages.ERROR ) # otherwise proceed but remove org users from the delete queryset return delete_selected(self, request, queryset)
def delete_selected_tree(self, modeladmin, request, queryset): """ Deletes multiple instances and makes sure the MPTT fields get recalculated properly. (Because merely doing a bulk delete doesn't trigger the post_delete hooks.) """ # If this is True, the confirmation page has been displayed if request.POST.get('post'): n = 0 # TODO: The disable_mptt_updates / rebuild is a work around # for what seems to be a mptt problem when deleting items # in a loop. Revisit this, there should be a better solution. with queryset.model.objects.disable_mptt_updates(): for obj in queryset: if self.has_delete_permission(request, obj): obj.delete() n += 1 obj_display = force_text(obj) self.log_deletion(request, obj, obj_display) else: logger.warning( "Denied delete request by \"%s\" for object #%s", request.user, obj.id) if n > 0: queryset.model.objects.rebuild() self.message_user( request, _("Successfully deleted %(count)d items.") % {"count": n}) # Return None to display the change list page again return None else: # (ab)using the built-in action to display the confirmation page return delete_selected(self, request, queryset)
def delete_selected_entity(modeladmin, request, queryset): """ Deletion action in the administration """ queryset._from_admin = True queryset._current_user = request.user return delete_selected(modeladmin, request, queryset)
def delete_selected(self, request, queryset): """ Override the built-in admin.site.delete_selected action to check each object against the is_authorized method. Note: this admin-specific action is only used if 'delete_selected' is explicitely included in actions=[...]. Otherwise, the site-wide default method is used. """ blocked = [] blocked_related = [] for obj in queryset: if not self.is_authorized(request.user, obj): blocked += [ obj ] if not blocked: blocked_related = self.related_not_authorized(request.user, queryset) if not blocked_related: ## Call default admin delete_selected action return actions.delete_selected(self, request, queryset) return self.delete_blocked_response(request, queryset, blocked, blocked_related)
def delete_selected(self, request, queryset): # We use processed ProblemPackage instances to store orignal package # files. if queryset.filter(status='OK').exists(): messages.error(request, _("Cannot delete a processed Problem Package")) else: return delete_selected(self, request, queryset)
def delete_selected(self, request, queryset): """ Override the built-in admin.site.delete_selected action to check each object against the is_authorized method. Note: this admin-specific action is only used if 'delete_selected' is explicitely included in actions=[...]. Otherwise, the site-wide default method is used. """ blocked = [] blocked_related = [] for obj in queryset: if not self.is_authorized(request.user, obj): blocked += [obj] if not blocked: blocked_related = self.related_not_authorized( request.user, queryset) if not blocked_related: ## Call default admin delete_selected action return actions.delete_selected(self, request, queryset) return self.delete_blocked_response(request, queryset, blocked, blocked_related)
def delete_selected_overridden(self, request, queryset): if not request.user.is_superuser: users_pk = queryset.values_list('pk', flat=True) owners_list = list( OrganizationOwner.objects.filter( organization_user__user__in=users_pk).select_related( 'organization_user__user').values_list( 'organization_user__user__username', flat=True)) owners = ', '.join(owners_list) excluded_owners_qs = queryset.exclude(username__in=owners_list) # if trying to delete any owner, show an error message count = len(owners_list) if count: self.message_user( request, ngettext( f"Can't delete %d organization owner: {owners}", f"Can't delete %d organization owners: {owners}", count, ) % count, messages.ERROR, ) # if trying to delete only owners, stop here if queryset.exists() and not excluded_owners_qs.exists(): redirect_url = reverse( f'admin:{self.model._meta.app_label}_user_changelist') return HttpResponseRedirect(redirect_url) # otherwise proceed but remove owners from the delete queryset else: queryset = excluded_owners_qs return delete_selected(self, request, queryset)
def delete_selected_tree(self, modeladmin, request, queryset): """ Deletes multiple instances and makes sure the MPTT fields get recalculated properly. (Because merely doing a bulk delete doesn't trigger the post_delete hooks.) """ # If this is True, the confirmation page has been displayed if request.POST.get('post'): n = 0 for obj in queryset: if self.has_delete_permission(request, obj): obj.delete() n += 1 obj_display = force_text(obj) self.log_deletion(request, obj, obj_display) else: logger.warning( "Denied delete request by \"%s\" for object #%s", request.user, obj.id) self.message_user( request, _("Successfully deleted %(count)d items.") % {"count": n}) # Return None to display the change list page again return None else: # (ab)using the built-in action to display the confirmation page return delete_selected(self, request, queryset)
def action_safe_bulk_delete(self, request, queryset): """Wrap the delete_selected method with the SafeDeleteQuerysetWrapper. That a confirmation form is presented to the user before deletion, and the delete() is overridden with _safe_delete() """ wrapped_queryset = BulkDeleteMixin.SafeDeleteQuerysetWrapper(queryset) return delete_selected(self, request, wrapped_queryset)
def delete_selected_tree(modeladmin, request, queryset): return_val = actions.delete_selected(modeladmin, request, queryset) if return_val is None: # this means deletion was completed tree_manager = getattr(modeladmin.model._meta,'tree_manager_attr','tree') tree = getattr(modeladmin.model,tree_manager) tree.rebuild() return return_val
def delete_selected_batch(self, request, queryset): if self.get_default_queryset(request, queryset).exists(): msg = _('Cannot proceed with the delete operation because ' 'the batch of items contains the default group, ' 'which cannot be deleted') self.message_user(request, msg, messages.ERROR) return False return delete_selected(self, request, queryset)
def clearLogs(self, request): # Deletes all log entries result = DeviceLog.objects.all() action = delete_selected(self, request, result) if action is None: return redirect(reverse('admin:slideshow_devicelog_changelist')) else: return action
def delete_selected_(modeladmin, request, queryset): if not modeladmin.has_delete_permission(request): raise PermissionDenied if request.POST.get('post'): for obj in queryset: obj.delete() else: return delete_selected(modeladmin, request, queryset)
def clearLogs(self, request): # Deletes all log entries result = Participant.objects.all() action = delete_selected(self, request, result) if action is None: return redirect(reverse('admin:questionnaire_participant_changelist')) else: return action
def delete_selected_ensure_canonical(self, request, queryset): val_errors = [] objs_to_mark_canonical = [] parents_to_delete = [] othercan = {} for obj in queryset: parent, siblings = obj.get_family() others_in_queryset = [] for other in siblings: if other in queryset: others_in_queryset.append(other) if other.canonical: othercan[obj] = othercan.get(obj, 0) + 1 # If there are no other objects or they're all selected for deletion, delete the associated parent if siblings.count() == 0 or siblings.count() == len( others_in_queryset): parents_to_delete.append(parent) # If there are no other objects for this parent, # or all the other objects are marked for deletion anyway, # or one of the other objects is marked canonical, # we don't need to do anything. Otherwise: if siblings.count() > 0 and siblings.count() != len( others_in_queryset) and othercan.get(obj, 0) < 1: # If there's only one other object for this parent, or only one after selecting others for deletion, # we only need to set its object as canonical if siblings.count( ) == 1 or siblings.count() - len(others_in_queryset) == 1: for sibling in siblings: if sibling not in others_in_queryset: objs_to_mark_canonical.append(sibling) else: # Otherwise, add an error link = reverse( 'admin:%s_%s_change' % (parent._meta.app_label, parent._meta.model_name), args=(parent.pk, )) val_errors.append( mark_safe( 'You may not delete \'{0}\' until you mark another {1} for <a href="{2}">{3}</a> as ' 'canonical.'.format(obj.name, obj._meta.model_name, link, obj.name))) if val_errors: for e in val_errors: super(CanonicalSdrBaseAdmin, self).message_user(request, e, messages.ERROR) return None else: for obj in objs_to_mark_canonical: obj.canonical = True obj.save() for p in parents_to_delete: p.delete() return delete_selected(self, request, queryset)
def action_safe_bulk_delete(self, request, queryset): for obj in queryset: obj.asset.asset_val = float(obj.depreciate_val) + float( obj.asset.asset_val) obj.asset.save() wrapped_queryset = AssetDepreciateAdmin.SafeDeleteQuerysetWrapper( queryset) return delete_selected(self, request, wrapped_queryset)
def delete_selected_tree(modeladmin, request, queryset): return_val = actions.delete_selected(modeladmin, request, queryset) if return_val is None: # this means deletion was completed tree_manager = getattr(modeladmin.model._meta, 'tree_manager_attr', 'tree') tree = getattr(modeladmin.model, tree_manager) tree.rebuild() return return_val
def delete_selected(self, request, queryset): parser = get_parser() tag_names = list(queryset.values_list('tag_name', flat=True)) response = actions.delete_selected(self, request, queryset) if response is None: [parser.bbcodes.pop(n) for n in tag_names] return response
def delete_selected(self, request, queryset): for obj in queryset: if obj.status == settings.SCAN_STATUS['in_process']: messages.error(request, _('Cannot delete scan in process.' 'Stop scan "%s" and try again') % obj.scan_task, ) return return delete_selected(self, request, queryset)
def delete_selected(self, request, queryset): for obj in queryset: if obj.status == settings.TASK_STATUS['lock']: messages.error(request, _('Cannot delete task in process. ' 'Stop task "%s" and try again') % obj.name, ) return return delete_selected(self, request, queryset)
def delete_from_dbs(self, request, queryset): """ Delete requested records from both databases. """ result = actions.delete_selected(self, request, queryset) if request.POST.get("post"): # The master copies (default write db for the model) have already # been deleted. We need to nuke the shadow copies. queryset.using("reviews-s").delete() return result
def _delete_selected(modeladmin, request, queryset): _delete_qs = queryset.delete def delete(): for obj in queryset: modeladmin.delete_model(request, obj) _delete_qs() queryset.delete = delete return delete_selected(modeladmin, request, queryset)
def delete_selected_and_artifacts(self, request, queryset): """Remove HTML/etc artifacts from application instances Prior to the query delete, broadcast tasks to delete HTML artifacts from application instances. """ if request.POST.get('post'): for project in queryset: broadcast(type='app', task=remove_dir, args=[project.doc_path]) return delete_selected(self, request, queryset)
def delete_selected(self, request, queryset): for obj in queryset: if obj.status == settings.TASK_STATUS['lock']: messages.error( request, _('Cannot delete task in process. ' 'Stop task "%s" and try again') % obj.name, ) return return delete_selected(self, request, queryset)
def delete_selected(self, request, queryset): for obj in queryset: if obj.status == settings.SCAN_STATUS['in_process']: messages.error( request, _('Cannot delete scan in process.' 'Stop scan "%s" and try again') % obj.scan_task, ) return return delete_selected(self, request, queryset)
def delete_selected_and_artifacts(self, request, queryset): """ Remove HTML/etc artifacts from storage. Prior to the query delete, broadcast tasks to delete HTML artifacts from application instances. """ if request.POST.get('post'): for project in queryset: clean_project_resources(project) return delete_selected(self, request, queryset)
def clear_cache_delete_selected(modeladmin, request, queryset): """ A delete action that will invalidate cache after being called. """ result = delete_selected(modeladmin, request, queryset) # A result of None means that the delete happened. if not result and hasattr(modeladmin, 'invalidate_cache'): modeladmin.invalidate_cache(queryset=queryset) return result
def delete_and_update_stats(self, request, queryset): ret = delete_selected(self, request, queryset) if request.POST.get('post'): teamset = set() for match in queryset: for team in (match.home_team, match.away_team): if team: teamset.add(team) for team in teamset: team.update_stats() return ret
def bulk_delete(modeladmin, request, queryset): for obj in queryset.all(): if has_related(modeladmin, obj): messages.error( request, _('One or more selected items, contains linked templates, can not be deleted.' )) return return delete_selected(modeladmin, request, queryset)
def delete_selected_tree(self, modeladmin, request, queryset): """ Deletes multiple instances and makes sure the MPTT fields get recalculated properly. (Because merely doing a bulk delete doesn't trigger the post_delete hooks.) """ # If the user has not yet confirmed the deletion, call the regular delete # action that will present a confirmation page if not request.POST.get('post'): return actions.delete_selected(modeladmin, request, queryset) # Otherwise, delete objects one by one n = 0 for obj in queryset: obj.delete() n += 1 self.message_user(request, _("Successfully deleted %s items." % n))
def delete_selected_recusively(self, request, queryset): """逐一删除""" if not request.POST.get("post"): return delete_selected(self, request, queryset) with transaction.atomic(): for o in queryset.all(): try: if not self.has_delete_permission(request, o): raise PermissionDenied o.delete() except WeChatClientException: msg = _("delete %(category)s failed: %(obj)s") % dict( category=self.model.verbose_name_plural, obj=o) self.logger(request).warning(msg, exc_info=True) raise
def delete_selected(modeladmin, request, queryset): filtered_qs = [] for obj in queryset: if modeladmin.has_delete_permission(request, obj): filtered_qs.append(obj.pk) else: messages.warning(request, _("Cannot delete %(name)s") % {"name": obj.title}) filtered_qs = Page.objects.filter(pk__in=filtered_qs) if filtered_qs: result = actions.delete_selected(modeladmin, request, filtered_qs) if not request.POST.get('post'): result.context_data['breadcrumbs'] = request.scms[ 'page'].full_load().parents return result else: return None
def cleanup_bundle_stream_selected(modeladmin, request, queryset): """ This action cleans up the bundles from a bundle stream, without remove the bundle stream itself. """ my_modeladmin = BundleAdmin(Bundle, modeladmin.admin_site) my_modeladmin.delete_selected_confirmation_template = 'admin/dashboard_app/cleanup_selected_bundle_confirmation.html' my_queryset = None if request.POST.get('post'): # handle bundles selected_bundles = request.POST.getlist('_selected_action') my_queryset = Bundle.objects.filter(pk__in=selected_bundles) else: # handle bundle streams for bundle_stream in queryset: if my_queryset is None: my_queryset = bundle_stream.bundles.all() else: my_queryset = my_queryset | bundle_stream.bundles.all() return delete_selected(my_modeladmin, request, my_queryset)
def delete_selected(self, request, queryset): ''' Remove the current user from the queryset selection and redirect to the changelist in case it was the only one. ''' me = self.get_auth_user(request.user) me_id = None for obj in queryset: if self.get_auth_user(obj).id == me.id: me_id = me.id queryset = queryset.exclude(id=me_id) if len(queryset): if me_id != None: messages.error(request, _('You cannot delete yourself! Removed you from selection.')) return actions.delete_selected(self, request, queryset) else: messages.error(request, _('You cannot delete yourself!')) return None
def delete_selected_tree(self, modeladmin, request, queryset): """ Deletes multiple instances and makes sure the MPTT fields get recalculated properly. (Because merely doing a bulk delete doesn't trigger the post_delete hooks.) """ # If this is True, the confirmation page has been displayed if request.POST.get('post'): n = 0 with queryset.model._tree_manager.delay_mptt_updates(): for obj in queryset: if self.has_delete_permission(request, obj): obj.delete() n += 1 obj_display = force_text(obj) self.log_deletion(request, obj, obj_display) self.message_user( request, _('Successfully deleted %(count)d items.') % {'count': n}) # Return None to display the change list page again return None else: # (ab)using the built-in action to display the confirmation page return delete_selected(self, request, queryset)
def item_admin_changelist(request): user=request.user try: act=request.POST["action"] if act=="delete_selected": if("post" not in request.POST): if(request.POST.getlist('_selected_action')==[]): messages.add_message(request, messages.INFO, 'Items must be selected in order to perform actions on them. No items have been changed.') raise ValueError() qs=Item.objects.filter(id__in=request.POST.getlist('_selected_action')) return delete_selected(ItemAdmin(Item,AdminSite()), request, qs) except: pass parent_categories=Category.objects.filter(parent=None) brands=Brand.objects.all() child_categories=[] selected_child_cat=None selected_parent_cat=None selected_brand=None query_search='' cats_filter=[] brand_filter=None try: filter_cat_id = int(request.GET['category']) filter_cat=Category.objects.get(id=filter_cat_id) if filter_cat.parent==None: selected_child_cat=None selected_parent_cat=filter_cat child_categories=Category.objects.filter(parent=selected_parent_cat.id) cats_filter.append(selected_parent_cat.id) cats_filter.extend(map(lambda c: c.id, child_categories)) else: selected_child_cat=filter_cat selected_parent_cat=filter_cat.parent cats_filter=[selected_child_cat.id,] child_categories=Category.objects.filter(parent=selected_parent_cat.id) except: cats_filter=[] try: brand_filter=int(request.GET['brand']) selected_brand=Brand.objects.get(id=brand_filter) except: brand_filter=None try: query_search=request.GET['q'] except: query_search='' filter_context={ } if cats_filter!=[]: filter_context['category__id__in']=cats_filter if brand_filter!=None: filter_context['brand__id__exact']=brand_filter if query_search!='': filter_context['name__icontains']=query_search orig_items=Item.objects.filter(**filter_context) paginator = Paginator(orig_items, 50) page = request.GET.get('page') is_all_items=None if page == '0': items=paginator.page(1) items.object_list=orig_items is_all_items = True else: if page == None: page=1 try: items = paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. items = paginator.page(1) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. items = paginator.page(paginator.num_pages) page_list=get_page_list(paginator,30,page) context={ 'has_add_permission': user.has_perm('catalog.add_item'), 'items': items, 'parent_categories': parent_categories, 'child_categories': child_categories, 'selected_child_cat':selected_child_cat, 'selected_parent_cat':selected_parent_cat, 'selected_brand': selected_brand, 'selected_category': selected_child_cat or selected_parent_cat, 'brands': brands, 'page_list':page_list, 'url_page': get_url(request, "page"), 'url_category': get_url(request, "category"), 'url_brand': get_url(request, "brand"), 'query_search': query_search, 'is_all_items': is_all_items, } context=RequestContext(request, context) return render_to_response('admin/catalog/item_changelist.html', context)
def delete_selected_vidyo_models(self, request, queryset): """The first half of this method is copied practically verbatim from django.contrib.admin.actions.delete_selected. However, the actual deletion is done within this method because django.contrib.admin uses queryset.delete() for efficiency. That method precludes the use of RPC. """ opts = self.model._meta # Check that the user has delete permission for the actual model if not self.has_delete_permission(request): raise PermissionDenied() using = router.db_for_write(self.model) # Populate deletable_objects, a data structure of all related objects that # will also be deleted. deletable_objects, perms_needed, protected = get_deleted_objects( queryset, opts, request.user, self.admin_site, using ) # If the POST querydict has get('post'), that means the submit button # has been submitted: Go ahead and delete if request.POST.get('post'): password = request.POST.get('password') if not password: self.message_user(request, _("Password Required"), messages.ERROR) return None if perms_needed: raise PermissionDenied() deleted_models = 0 for obj in queryset: obj_display = force_text(obj) self.log_deletion(request, obj, obj_display) try: obj.decrypt(password) except ValueError: continue obj.delete() deleted_models += 1 if len(queryset) > deleted_models: self.message_user( request, _("couldn't delete all %ss: some were skipped") % str(type(self)), messages.WARNING ) else: self.message_user( request, _("Successfully deleted %(number)s %(type)ss") % { 'number': deleted_models, 'type': self.model }, messages.SUCCESS ) return None # If the POST doesn't contain 'post' key that means we're not yet ready # to do the full deletion, so let django.contrib.admin render the # confirmation page with our overridden template else: return delete_selected(self, request, queryset)
def _delete_selected(modeladmin, request, queryset): print modeladmin.__class__.__name__ if modeladmin.__class__.__name__ == 'CoreAdmin': # my custom code #return delete_selected(modeladmin, request, queryset) all = queryset.all() print type(all) print all print all.first() default_found = False for core in queryset.all(): if core.title == 'default': default_found = True print "Default found" if default_found: opts = modeladmin.model._meta app_label = opts.app_label # Check that the user has delete permission for the actual model if not modeladmin.has_delete_permission(request): raise PermissionDenied using = router.db_for_write(modeladmin.model) # Populate deletable_objects, a data structure of all related objects that # will also be deleted. deletable_objects, perms_needed, protected = get_deleted_objects( queryset, opts, request.user, modeladmin.admin_site, using) # The user has already confirmed the deletion. # Do the deletion and return a None to display the change list view again. if request.POST.get('post'): if perms_needed: raise PermissionDenied n = queryset.count() if n: for obj in queryset: obj_display = force_text(obj) modeladmin.log_deletion(request, obj, obj_display) queryset.delete() modeladmin.message_user(request, _("Successfully deleted %(count)d %(items)s.") % { "count": n, "items": model_ngettext(modeladmin.opts, n) }, messages.SUCCESS) # Return None to display the change list page again. return None if len(queryset) == 1: objects_name = force_text(opts.verbose_name) else: objects_name = force_text(opts.verbose_name_plural) # if we selected more than 1 cores, remove all others except the default cores because we do not want # to render them in the not allowed list - they CAN be deleted, it's just that in the list # there is a default core selected as well # other solution is do clear the list and add only one - default core if queryset.count() > 1: deletable_objects = [core for core in deletable_objects if core.find('default') != -1] # for core in deletable_objects: # print core # print type(core) context = { "title": "Not allowed", "objects_name": objects_name, "deletable_objects": [deletable_objects], 'queryset': queryset, "perms_lacking": perms_needed, "protected": protected, "opts": opts, "app_label": app_label, 'action_checkbox_name': helpers.ACTION_CHECKBOX_NAME, } # Display the confirmation page return TemplateResponse(request, "admin/delete_not_allowed.html", context, current_app=modeladmin.admin_site.name) else: return delete_selected(modeladmin, request, queryset) else: #call default one return delete_selected(modeladmin, request, queryset)
def action_safe_bulk_delete(self, request, queryset): wrapped_queryset = BulkDeleteMixin.SafeDeleteQuerysetWrapper(queryset) return delete_selected(self, request, wrapped_queryset)
def delete_selected(self, request, queryset): """Bypass soft delete and really delete selected instances.""" queryset.delete = partial(queryset.delete, permanent=True) return actions.delete_selected(self, request, queryset)
def delete_selected(self, request, queryset): for object in queryset.all(): self.delete_warning_msg(request, object) return delete_selected(self, request, queryset)
def delete_empty(self, request, queryset): # Do not allow to delete built-in specializations. queryset = self.queryset_is_protected(queryset) # call Django's delete_selected with limited queryset delete_selected(self, request, queryset) pass
def empty_table(modeladmin, request, queryset): if not modeladmin.has_delete_permission(request): raise PermissionDenied delete_selected(modeladmin, request, modeladmin.model.objects.all())
def delete_all(modeladmin, request, queryset): if not modeladmin.has_delete_permission(request): raise PermissionDenied return delete_selected(modeladmin, request, modeladmin.model.objects.all())
def nested_delete_selected(modeladmin, req, qs): response = delete_selected(modeladmin, req, qs) if response: response.context_data.update(self.context_add_parent_data()) return response