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(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 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_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_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(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):
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_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.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 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 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_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 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_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
