/django/contrib/admin/util.py
https://code.google.com/p/mango-py/ · Python · 387 lines · 336 code · 22 blank · 29 comment · 24 complexity · 001d2f6feb873e6cc09c50ea85f413e0 MD5 · raw file
- from django.db import models
- from django.db.models.sql.constants import LOOKUP_SEP
- from django.db.models.deletion import Collector
- from django.db.models.related import RelatedObject
- from django.forms.forms import pretty_name
- from django.utils import formats
- from django.utils.html import escape
- from django.utils.safestring import mark_safe
- from django.utils.text import capfirst
- from django.utils.encoding import force_unicode, smart_unicode, smart_str
- from django.utils.translation import ungettext
- from django.core.urlresolvers import reverse
- def quote(s):
- """
- Ensure that primary key values do not confuse the admin URLs by escaping
- any '/', '_' and ':' characters. Similar to urllib.quote, except that the
- quoting is slightly different so that it doesn't get automatically
- unquoted by the Web browser.
- """
- if not isinstance(s, basestring):
- return s
- res = list(s)
- for i in range(len(res)):
- c = res[i]
- if c in """:/_#?;@&=+$,"<>%\\""":
- res[i] = '_%02X' % ord(c)
- return ''.join(res)
- def unquote(s):
- """
- Undo the effects of quote(). Based heavily on urllib.unquote().
- """
- mychr = chr
- myatoi = int
- list = s.split('_')
- res = [list[0]]
- myappend = res.append
- del list[0]
- for item in list:
- if item[1:2]:
- try:
- myappend(mychr(myatoi(item[:2], 16)) + item[2:])
- except ValueError:
- myappend('_' + item)
- else:
- myappend('_' + item)
- return "".join(res)
- def flatten_fieldsets(fieldsets):
- """Returns a list of field names from an admin fieldsets structure."""
- field_names = []
- for name, opts in fieldsets:
- for field in opts['fields']:
- # type checking feels dirty, but it seems like the best way here
- if type(field) == tuple:
- field_names.extend(field)
- else:
- field_names.append(field)
- return field_names
- def get_deleted_objects(objs, opts, user, admin_site, using):
- """
- Find all objects related to ``objs`` that should also be deleted. ``objs``
- must be a homogenous iterable of objects (e.g. a QuerySet).
- Returns a nested list of strings suitable for display in the
- template with the ``unordered_list`` filter.
- """
- collector = NestedObjects(using=using)
- collector.collect(objs)
- perms_needed = set()
- def format_callback(obj):
- has_admin = obj.__class__ in admin_site._registry
- opts = obj._meta
- if has_admin:
- admin_url = reverse('%s:%s_%s_change'
- % (admin_site.name,
- opts.app_label,
- opts.object_name.lower()),
- None, (quote(obj._get_pk_val()),))
- p = '%s.%s' % (opts.app_label,
- opts.get_delete_permission())
- if not user.has_perm(p):
- perms_needed.add(opts.verbose_name)
- # Display a link to the admin page.
- return mark_safe(u'%s: <a href="%s">%s</a>' %
- (escape(capfirst(opts.verbose_name)),
- admin_url,
- escape(obj)))
- else:
- # Don't display link to edit, because it either has no
- # admin or is edited inline.
- return u'%s: %s' % (capfirst(opts.verbose_name),
- force_unicode(obj))
- to_delete = collector.nested(format_callback)
- protected = [format_callback(obj) for obj in collector.protected]
- return to_delete, perms_needed, protected
- class NestedObjects(Collector):
- def __init__(self, *args, **kwargs):
- super(NestedObjects, self).__init__(*args, **kwargs)
- self.edges = {} # {from_instance: [to_instances]}
- self.protected = set()
- def add_edge(self, source, target):
- self.edges.setdefault(source, []).append(target)
- def collect(self, objs, source_attr=None, **kwargs):
- for obj in objs:
- if source_attr:
- self.add_edge(getattr(obj, source_attr), obj)
- else:
- self.add_edge(None, obj)
- try:
- return super(NestedObjects, self).collect(objs, source_attr=source_attr, **kwargs)
- except models.ProtectedError, e:
- self.protected.update(e.protected_objects)
- def related_objects(self, related, objs):
- qs = super(NestedObjects, self).related_objects(related, objs)
- return qs.select_related(related.field.name)
- def _nested(self, obj, seen, format_callback):
- if obj in seen:
- return []
- seen.add(obj)
- children = []
- for child in self.edges.get(obj, ()):
- children.extend(self._nested(child, seen, format_callback))
- if format_callback:
- ret = [format_callback(obj)]
- else:
- ret = [obj]
- if children:
- ret.append(children)
- return ret
- def nested(self, format_callback=None):
- """
- Return the graph as a nested list.
- """
- seen = set()
- roots = []
- for root in self.edges.get(None, ()):
- roots.extend(self._nested(root, seen, format_callback))
- return roots
- def model_format_dict(obj):
- """
- Return a `dict` with keys 'verbose_name' and 'verbose_name_plural',
- typically for use with string formatting.
- `obj` may be a `Model` instance, `Model` subclass, or `QuerySet` instance.
- """
- if isinstance(obj, (models.Model, models.base.ModelBase)):
- opts = obj._meta
- elif isinstance(obj, models.query.QuerySet):
- opts = obj.model._meta
- else:
- opts = obj
- return {
- 'verbose_name': force_unicode(opts.verbose_name),
- 'verbose_name_plural': force_unicode(opts.verbose_name_plural)
- }
- def model_ngettext(obj, n=None):
- """
- Return the appropriate `verbose_name` or `verbose_name_plural` value for
- `obj` depending on the count `n`.
- `obj` may be a `Model` instance, `Model` subclass, or `QuerySet` instance.
- If `obj` is a `QuerySet` instance, `n` is optional and the length of the
- `QuerySet` is used.
- """
- if isinstance(obj, models.query.QuerySet):
- if n is None:
- n = obj.count()
- obj = obj.model
- d = model_format_dict(obj)
- singular, plural = d["verbose_name"], d["verbose_name_plural"]
- return ungettext(singular, plural, n or 0)
- def lookup_field(name, obj, model_admin=None):
- opts = obj._meta
- try:
- f = opts.get_field(name)
- except models.FieldDoesNotExist:
- # For non-field values, the value is either a method, property or
- # returned via a callable.
- if callable(name):
- attr = name
- value = attr(obj)
- elif (model_admin is not None and hasattr(model_admin, name) and
- not name == '__str__' and not name == '__unicode__'):
- attr = getattr(model_admin, name)
- value = attr(obj)
- else:
- attr = getattr(obj, name)
- if callable(attr):
- value = attr()
- else:
- value = attr
- f = None
- else:
- attr = None
- value = getattr(obj, name)
- return f, attr, value
- def label_for_field(name, model, model_admin=None, return_attr=False):
- attr = None
- try:
- field = model._meta.get_field_by_name(name)[0]
- if isinstance(field, RelatedObject):
- label = field.opts.verbose_name
- else:
- label = field.verbose_name
- except models.FieldDoesNotExist:
- if name == "__unicode__":
- label = force_unicode(model._meta.verbose_name)
- elif name == "__str__":
- label = smart_str(model._meta.verbose_name)
- else:
- if callable(name):
- attr = name
- elif model_admin is not None and hasattr(model_admin, name):
- attr = getattr(model_admin, name)
- elif hasattr(model, name):
- attr = getattr(model, name)
- else:
- message = "Unable to lookup '%s' on %s" % (name, model._meta.object_name)
- if model_admin:
- message += " or %s" % (model_admin.__class__.__name__,)
- raise AttributeError(message)
- if hasattr(attr, "short_description"):
- label = attr.short_description
- elif callable(attr):
- if attr.__name__ == "<lambda>":
- label = "--"
- else:
- label = pretty_name(attr.__name__)
- else:
- label = pretty_name(name)
- if return_attr:
- return (label, attr)
- else:
- return label
- def help_text_for_field(name, model):
- try:
- help_text = model._meta.get_field_by_name(name)[0].help_text
- except models.FieldDoesNotExist:
- help_text = ""
- return smart_unicode(help_text)
- def display_for_field(value, field):
- from django.contrib.admin.templatetags.admin_list import _boolean_icon
- from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
- if field.flatchoices:
- return dict(field.flatchoices).get(value, EMPTY_CHANGELIST_VALUE)
- # NullBooleanField needs special-case null-handling, so it comes
- # before the general null test.
- elif isinstance(field, models.BooleanField) or isinstance(field, models.NullBooleanField):
- return _boolean_icon(value)
- elif value is None:
- return EMPTY_CHANGELIST_VALUE
- elif isinstance(field, models.DateField) or isinstance(field, models.TimeField):
- return formats.localize(value)
- elif isinstance(field, models.DecimalField):
- return formats.number_format(value, field.decimal_places)
- elif isinstance(field, models.FloatField):
- return formats.number_format(value)
- else:
- return smart_unicode(value)
- class NotRelationField(Exception):
- pass
- def get_model_from_relation(field):
- if isinstance(field, models.related.RelatedObject):
- return field.model
- elif getattr(field, 'rel'): # or isinstance?
- return field.rel.to
- else:
- raise NotRelationField
- def reverse_field_path(model, path):
- """ Create a reversed field path.
- E.g. Given (Order, "user__groups"),
- return (Group, "user__order").
- Final field must be a related model, not a data field.
- """
- reversed_path = []
- parent = model
- pieces = path.split(LOOKUP_SEP)
- for piece in pieces:
- field, model, direct, m2m = parent._meta.get_field_by_name(piece)
- # skip trailing data field if extant:
- if len(reversed_path) == len(pieces)-1: # final iteration
- try:
- get_model_from_relation(field)
- except NotRelationField:
- break
- if direct:
- related_name = field.related_query_name()
- parent = field.rel.to
- else:
- related_name = field.field.name
- parent = field.model
- reversed_path.insert(0, related_name)
- return (parent, LOOKUP_SEP.join(reversed_path))
- def get_fields_from_path(model, path):
- """ Return list of Fields given path relative to model.
- e.g. (ModelX, "user__groups__name") -> [
- <django.db.models.fields.related.ForeignKey object at 0x...>,
- <django.db.models.fields.related.ManyToManyField object at 0x...>,
- <django.db.models.fields.CharField object at 0x...>,
- ]
- """
- pieces = path.split(LOOKUP_SEP)
- fields = []
- for piece in pieces:
- if fields:
- parent = get_model_from_relation(fields[-1])
- else:
- parent = model
- fields.append(parent._meta.get_field_by_name(piece)[0])
- return fields
- def remove_trailing_data_field(fields):
- """ Discard trailing non-relation field if extant. """
- try:
- get_model_from_relation(fields[-1])
- except NotRelationField:
- fields = fields[:-1]
- return fields
- def get_limit_choices_to_from_path(model, path):
- """ Return Q object for limiting choices if applicable.
- If final model in path is linked via a ForeignKey or ManyToManyField which
- has a `limit_choices_to` attribute, return it as a Q object.
- """
- fields = get_fields_from_path(model, path)
- fields = remove_trailing_data_field(fields)
- limit_choices_to = (
- fields and hasattr(fields[-1], 'rel') and
- getattr(fields[-1].rel, 'limit_choices_to', None))
- if not limit_choices_to:
- return models.Q() # empty Q
- elif isinstance(limit_choices_to, models.Q):
- return limit_choices_to # already a Q
- else:
- return models.Q(**limit_choices_to) # convert dict to Q