from django.conf import settings from django.db.models.related import RelatedObject from django.db.models.fields.related import ManyToManyRel from django.db.models.fields import AutoField, FieldDoesNotExist from django.db.models.loading import get_models, app_cache_ready from django.db.models.query import orderlist2sql from django.db.models import Manager from django.utils.translation import activate, deactivate_all, get_language, string_concat from django.utils.encoding import force_unicode, smart_str from bisect import bisect import re # Calculate the verbose_name by converting from InitialCaps to "lowercase with spaces". get_verbose_name = lambda class_name: re.sub('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))', ' \\1', class_name).lower().strip() DEFAULT_NAMES = ('verbose_name', 'db_table', 'ordering', 'unique_together', 'permissions', 'get_latest_by', 'order_with_respect_to', 'app_label', 'db_tablespace') class Options(object): def __init__(self, meta): self.fields, self.many_to_many = [], [] self.module_name, self.verbose_name = None, None self.verbose_name_plural = None self.db_table = '' self.ordering = [] self.unique_together = [] self.permissions = [] self.object_name, self.app_label = None, None self.get_latest_by = None self.order_with_respect_to = None self.db_tablespace = None self.admin = None self.meta = meta self.pk = None self.has_auto_field = False self.one_to_one_field = None self.parents = [] def contribute_to_class(self, cls, name): cls._meta = self self.installed = re.sub('\.models$', '', cls.__module__) in settings.INSTALLED_APPS # First, construct the default values for these options. self.object_name = cls.__name__ self.module_name = self.object_name.lower() self.verbose_name = get_verbose_name(self.object_name) # Next, apply any overridden values from 'class Meta'. if self.meta: meta_attrs = self.meta.__dict__ del meta_attrs['__module__'] del meta_attrs['__doc__'] for attr_name in DEFAULT_NAMES: setattr(self, attr_name, meta_attrs.pop(attr_name, getattr(self, attr_name))) # verbose_name_plural is a special case because it uses a 's' # by default. setattr(self, 'verbose_name_plural', meta_attrs.pop('verbose_name_plural', string_concat(self.verbose_name, 's'))) # Any leftover attributes must be invalid. if meta_attrs != {}: raise TypeError, "'class Meta' got invalid attribute(s): %s" % ','.join(meta_attrs.keys()) else: self.verbose_name_plural = string_concat(self.verbose_name, 's') del self.meta def _prepare(self, model): from django.db import backend from django.db.backends.util import truncate_name if self.order_with_respect_to: self.order_with_respect_to = self.get_field(self.order_with_respect_to) self.ordering = ('_order',) else: self.order_with_respect_to = None if self.pk is None: auto = AutoField(verbose_name='ID', primary_key=True) auto.creation_counter = -1 model.add_to_class('id', auto) # If the db_table wasn't provided, use the app_label + module_name. if not self.db_table: self.db_table = "%s_%s" % (self.app_label, self.module_name) self.db_table = truncate_name(self.db_table, backend.get_max_name_length()) def add_field(self, field): # Insert the given field in the order in which it was created, using # the "creation_counter" attribute of the field. # Move many-to-many related fields from self.fields into self.many_to_many. if field.rel and isinstance(field.rel, ManyToManyRel): self.many_to_many.insert(bisect(self.many_to_many, field), field) else: self.fields.insert(bisect(self.fields, field), field) if not self.pk and field.primary_key: self.pk = field field.serialize = False def __repr__(self): return '' % self.object_name def __str__(self): return "%s.%s" % (smart_str(self.app_label), smart_str(self.module_name)) def verbose_name_raw(self): """ There are a few places where the untranslated verbose name is needed (so that we get the same value regardless of currently active locale). """ lang = get_language() deactivate_all() raw = force_unicode(self.verbose_name) activate(lang) return raw verbose_name_raw = property(verbose_name_raw) def get_field(self, name, many_to_many=True): "Returns the requested field by name. Raises FieldDoesNotExist on error." to_search = many_to_many and (self.fields + self.many_to_many) or self.fields for f in to_search: if f.name == name: return f raise FieldDoesNotExist, '%s has no field named %r' % (self.object_name, name) def get_order_sql(self, table_prefix=''): "Returns the full 'ORDER BY' clause for this object, according to self.ordering." if not self.ordering: return '' pre = table_prefix and (table_prefix + '.') or '' return 'ORDER BY ' + orderlist2sql(self.ordering, self, pre) def get_add_permission(self): return 'add_%s' % self.object_name.lower() def get_change_permission(self): return 'change_%s' % self.object_name.lower() def get_delete_permission(self): return 'delete_%s' % self.object_name.lower() def get_all_related_objects(self): try: # Try the cache first. return self._all_related_objects except AttributeError: rel_objs = [] for klass in get_models(): for f in klass._meta.fields: if f.rel and self == f.rel.to._meta: rel_objs.append(RelatedObject(f.rel.to, klass, f)) self._all_related_objects = rel_objs return rel_objs def get_followed_related_objects(self, follow=None): if follow == None: follow = self.get_follow() return [f for f in self.get_all_related_objects() if follow.get(f.name, None)] def get_data_holders(self, follow=None): if follow == None: follow = self.get_follow() return [f for f in self.fields + self.many_to_many + self.get_all_related_objects() if follow.get(f.name, None)] def get_follow(self, override=None): follow = {} for f in self.fields + self.many_to_many + self.get_all_related_objects(): if override and f.name in override: child_override = override[f.name] else: child_override = None fol = f.get_follow(child_override) if fol != None: follow[f.name] = fol return follow def get_all_related_many_to_many_objects(self): try: # Try the cache first. return self._all_related_many_to_many_objects except AttributeError: rel_objs = [] for klass in get_models(): for f in klass._meta.many_to_many: if f.rel and self == f.rel.to._meta: rel_objs.append(RelatedObject(f.rel.to, klass, f)) if app_cache_ready(): self._all_related_many_to_many_objects = rel_objs return rel_objs def get_ordered_objects(self): "Returns a list of Options objects that are ordered with respect to this object." if not hasattr(self, '_ordered_objects'): objects = [] # TODO #for klass in get_models(get_app(self.app_label)): # opts = klass._meta # if opts.order_with_respect_to and opts.order_with_respect_to.rel \ # and self == opts.order_with_respect_to.rel.to._meta: # objects.append(opts) self._ordered_objects = objects return self._ordered_objects def has_field_type(self, field_type, follow=None): """ Returns True if this object's admin form has at least one of the given field_type (e.g. FileField). """ # TODO: follow if not hasattr(self, '_field_types'): self._field_types = {} if field_type not in self._field_types: try: # First check self.fields. for f in self.fields: if isinstance(f, field_type): raise StopIteration # Failing that, check related fields. for related in self.get_followed_related_objects(follow): for f in related.opts.fields: if isinstance(f, field_type): raise StopIteration except StopIteration: self._field_types[field_type] = True else: self._field_types[field_type] = False return self._field_types[field_type] class AdminOptions(object): def __init__(self, fields=None, js=None, list_display=None, list_display_links=None, list_filter=None, date_hierarchy=None, save_as=False, ordering=None, search_fields=None, save_on_top=False, list_select_related=False, manager=None, list_per_page=100): self.fields = fields self.js = js or [] self.list_display = list_display or ['__str__'] self.list_display_links = list_display_links or [] self.list_filter = list_filter or [] self.date_hierarchy = date_hierarchy self.save_as, self.ordering = save_as, ordering self.search_fields = search_fields or [] self.save_on_top = save_on_top self.list_select_related = list_select_related self.list_per_page = list_per_page self.manager = manager or Manager() def get_field_sets(self, opts): "Returns a list of AdminFieldSet objects for this AdminOptions object." if self.fields is None: field_struct = ((None, {'fields': [f.name for f in opts.fields + opts.many_to_many if f.editable and not isinstance(f, AutoField)]}),) else: field_struct = self.fields new_fieldset_list = [] for fieldset in field_struct: fs_options = fieldset[1] classes = fs_options.get('classes', ()) description = fs_options.get('description', '') new_fieldset_list.append(AdminFieldSet(fieldset[0], classes, opts.get_field, fs_options['fields'], description)) return new_fieldset_list def contribute_to_class(self, cls, name): cls._meta.admin = self # Make sure the admin manager has access to the model self.manager.model = cls class AdminFieldSet(object): def __init__(self, name, classes, field_locator_func, line_specs, description): self.name = name self.field_lines = [AdminFieldLine(field_locator_func, line_spec) for line_spec in line_specs] self.classes = classes self.description = description def __repr__(self): return "FieldSet: (%s, %s)" % (self.name, self.field_lines) def bind(self, field_mapping, original, bound_field_set_class): return bound_field_set_class(self, field_mapping, original) def __iter__(self): for field_line in self.field_lines: yield field_line def __len__(self): return len(self.field_lines) class AdminFieldLine(object): def __init__(self, field_locator_func, linespec): if isinstance(linespec, basestring): self.fields = [field_locator_func(linespec)] else: self.fields = [field_locator_func(field_name) for field_name in linespec] def bind(self, field_mapping, original, bound_field_line_class): return bound_field_line_class(self, field_mapping, original) def __iter__(self): for field in self.fields: yield field def __len__(self): return len(self.fields)