| import types |
| import sys |
| from itertools import izip |
| import django.db.models.manager # Imported to register signal handler. |
| from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned, FieldError, ValidationError, NON_FIELD_ERRORS |
| from django.core import validators |
| from django.db.models.fields import AutoField, FieldDoesNotExist |
| from django.db.models.fields.related import (OneToOneRel, ManyToOneRel, |
| OneToOneField, add_lazy_relation) |
| from django.db.models.query import Q |
| from django.db.models.query_utils import DeferredAttribute |
| from django.db.models.deletion import Collector |
| from django.db.models.options import Options |
| from django.db import (connections, router, transaction, DatabaseError, |
| DEFAULT_DB_ALIAS) |
| from django.db.models import signals |
| from django.db.models.loading import register_models, get_model |
| from django.utils.translation import ugettext_lazy as _ |
| import django.utils.copycompat as copy |
| from django.utils.functional import curry, update_wrapper |
| from django.utils.encoding import smart_str, force_unicode |
| from django.utils.text import get_text_list, capfirst |
| from django.conf import settings |
| |
| class ModelBase(type): |
| """ |
| Metaclass for all models. |
| """ |
| def __new__(cls, name, bases, attrs): |
| super_new = super(ModelBase, cls).__new__ |
| parents = [b for b in bases if isinstance(b, ModelBase)] |
| if not parents: |
| # If this isn't a subclass of Model, don't do anything special. |
| return super_new(cls, name, bases, attrs) |
| |
| # Create the class. |
| module = attrs.pop('__module__') |
| new_class = super_new(cls, name, bases, {'__module__': module}) |
| attr_meta = attrs.pop('Meta', None) |
| abstract = getattr(attr_meta, 'abstract', False) |
| if not attr_meta: |
| meta = getattr(new_class, 'Meta', None) |
| else: |
| meta = attr_meta |
| base_meta = getattr(new_class, '_meta', None) |
| |
| if getattr(meta, 'app_label', None) is None: |
| # Figure out the app_label by looking one level up. |
| # For 'django.contrib.sites.models', this would be 'sites'. |
| model_module = sys.modules[new_class.__module__] |
| kwargs = {"app_label": model_module.__name__.split('.')[-2]} |
| else: |
| kwargs = {} |
| |
| new_class.add_to_class('_meta', Options(meta, **kwargs)) |
| if not abstract: |
| new_class.add_to_class('DoesNotExist', subclass_exception('DoesNotExist', |
| tuple(x.DoesNotExist |
| for x in parents if hasattr(x, '_meta') and not x._meta.abstract) |
| or (ObjectDoesNotExist,), module)) |
| new_class.add_to_class('MultipleObjectsReturned', subclass_exception('MultipleObjectsReturned', |
| tuple(x.MultipleObjectsReturned |
| for x in parents if hasattr(x, '_meta') and not x._meta.abstract) |
| or (MultipleObjectsReturned,), module)) |
| if base_meta and not base_meta.abstract: |
| # Non-abstract child classes inherit some attributes from their |
| # non-abstract parent (unless an ABC comes before it in the |
| # method resolution order). |
| if not hasattr(meta, 'ordering'): |
| new_class._meta.ordering = base_meta.ordering |
| if not hasattr(meta, 'get_latest_by'): |
| new_class._meta.get_latest_by = base_meta.get_latest_by |
| |
| is_proxy = new_class._meta.proxy |
| |
| if getattr(new_class, '_default_manager', None): |
| if not is_proxy: |
| # Multi-table inheritance doesn't inherit default manager from |
| # parents. |
| new_class._default_manager = None |
| new_class._base_manager = None |
| else: |
| # Proxy classes do inherit parent's default manager, if none is |
| # set explicitly. |
| new_class._default_manager = new_class._default_manager._copy_to_model(new_class) |
| new_class._base_manager = new_class._base_manager._copy_to_model(new_class) |
| |
| # Bail out early if we have already created this class. |
| m = get_model(new_class._meta.app_label, name, False) |
| if m is not None: |
| return m |
| |
| # Add all attributes to the class. |
| for obj_name, obj in attrs.items(): |
| new_class.add_to_class(obj_name, obj) |
| |
| # All the fields of any type declared on this model |
| new_fields = new_class._meta.local_fields + \ |
| new_class._meta.local_many_to_many + \ |
| new_class._meta.virtual_fields |
| field_names = set([f.name for f in new_fields]) |
| |
| # Basic setup for proxy models. |
| if is_proxy: |
| base = None |
| for parent in [cls for cls in parents if hasattr(cls, '_meta')]: |
| if parent._meta.abstract: |
| if parent._meta.fields: |
| raise TypeError("Abstract base class containing model fields not permitted for proxy model '%s'." % name) |
| else: |
| continue |
| if base is not None: |
| raise TypeError("Proxy model '%s' has more than one non-abstract model base class." % name) |
| else: |
| base = parent |
| if base is None: |
| raise TypeError("Proxy model '%s' has no non-abstract model base class." % name) |
| if (new_class._meta.local_fields or |
| new_class._meta.local_many_to_many): |
| raise FieldError("Proxy model '%s' contains model fields." % name) |
| while base._meta.proxy: |
| base = base._meta.proxy_for_model |
| new_class._meta.setup_proxy(base) |
| |
| # Do the appropriate setup for any model parents. |
| o2o_map = dict([(f.rel.to, f) for f in new_class._meta.local_fields |
| if isinstance(f, OneToOneField)]) |
| |
| for base in parents: |
| original_base = base |
| if not hasattr(base, '_meta'): |
| # Things without _meta aren't functional models, so they're |
| # uninteresting parents. |
| continue |
| |
| parent_fields = base._meta.local_fields + base._meta.local_many_to_many |
| # Check for clashes between locally declared fields and those |
| # on the base classes (we cannot handle shadowed fields at the |
| # moment). |
| for field in parent_fields: |
| if field.name in field_names: |
| raise FieldError('Local field %r in class %r clashes ' |
| 'with field of similar name from ' |
| 'base class %r' % |
| (field.name, name, base.__name__)) |
| if not base._meta.abstract: |
| # Concrete classes... |
| while base._meta.proxy: |
| # Skip over a proxy class to the "real" base it proxies. |
| base = base._meta.proxy_for_model |
| if base in o2o_map: |
| field = o2o_map[base] |
| elif not is_proxy: |
| attr_name = '%s_ptr' % base._meta.module_name |
| field = OneToOneField(base, name=attr_name, |
| auto_created=True, parent_link=True) |
| new_class.add_to_class(attr_name, field) |
| else: |
| field = None |
| new_class._meta.parents[base] = field |
| else: |
| # .. and abstract ones. |
| for field in parent_fields: |
| new_class.add_to_class(field.name, copy.deepcopy(field)) |
| |
| # Pass any non-abstract parent classes onto child. |
| new_class._meta.parents.update(base._meta.parents) |
| |
| # Inherit managers from the abstract base classes. |
| new_class.copy_managers(base._meta.abstract_managers) |
| |
| # Proxy models inherit the non-abstract managers from their base, |
| # unless they have redefined any of them. |
| if is_proxy: |
| new_class.copy_managers(original_base._meta.concrete_managers) |
| |
| # Inherit virtual fields (like GenericForeignKey) from the parent |
| # class |
| for field in base._meta.virtual_fields: |
| if base._meta.abstract and field.name in field_names: |
| raise FieldError('Local field %r in class %r clashes '\ |
| 'with field of similar name from '\ |
| 'abstract base class %r' % \ |
| (field.name, name, base.__name__)) |
| new_class.add_to_class(field.name, copy.deepcopy(field)) |
| |
| if abstract: |
| # Abstract base models can't be instantiated and don't appear in |
| # the list of models for an app. We do the final setup for them a |
| # little differently from normal models. |
| attr_meta.abstract = False |
| new_class.Meta = attr_meta |
| return new_class |
| |
| new_class._prepare() |
| register_models(new_class._meta.app_label, new_class) |
| |
| # Because of the way imports happen (recursively), we may or may not be |
| # the first time this model tries to register with the framework. There |
| # should only be one class for each model, so we always return the |
| # registered version. |
| return get_model(new_class._meta.app_label, name, False) |
| |
| def copy_managers(cls, base_managers): |
| # This is in-place sorting of an Options attribute, but that's fine. |
| base_managers.sort() |
| for _, mgr_name, manager in base_managers: |
| val = getattr(cls, mgr_name, None) |
| if not val or val is manager: |
| new_manager = manager._copy_to_model(cls) |
| cls.add_to_class(mgr_name, new_manager) |
| |
| def add_to_class(cls, name, value): |
| if hasattr(value, 'contribute_to_class'): |
| value.contribute_to_class(cls, name) |
| else: |
| setattr(cls, name, value) |
| |
| def _prepare(cls): |
| """ |
| Creates some methods once self._meta has been populated. |
| """ |
| opts = cls._meta |
| opts._prepare(cls) |
| |
| if opts.order_with_respect_to: |
| cls.get_next_in_order = curry(cls._get_next_or_previous_in_order, is_next=True) |
| cls.get_previous_in_order = curry(cls._get_next_or_previous_in_order, is_next=False) |
| # defer creating accessors on the foreign class until we are |
| # certain it has been created |
| def make_foreign_order_accessors(field, model, cls): |
| setattr( |
| field.rel.to, |
| 'get_%s_order' % cls.__name__.lower(), |
| curry(method_get_order, cls) |
| ) |
| setattr( |
| field.rel.to, |
| 'set_%s_order' % cls.__name__.lower(), |
| curry(method_set_order, cls) |
| ) |
| add_lazy_relation( |
| cls, |
| opts.order_with_respect_to, |
| opts.order_with_respect_to.rel.to, |
| make_foreign_order_accessors |
| ) |
| |
| # Give the class a docstring -- its definition. |
| if cls.__doc__ is None: |
| cls.__doc__ = "%s(%s)" % (cls.__name__, ", ".join([f.attname for f in opts.fields])) |
| |
| if hasattr(cls, 'get_absolute_url'): |
| cls.get_absolute_url = update_wrapper(curry(get_absolute_url, opts, cls.get_absolute_url), |
| cls.get_absolute_url) |
| |
| signals.class_prepared.send(sender=cls) |
| |
| class ModelState(object): |
| """ |
| A class for storing instance state |
| """ |
| def __init__(self, db=None): |
| self.db = db |
| # If true, uniqueness validation checks will consider this a new, as-yet-unsaved object. |
| # Necessary for correct validation of new instances of objects with explicit (non-auto) PKs. |
| # This impacts validation only; it has no effect on the actual save. |
| self.adding = True |
| |
| class Model(object): |
| __metaclass__ = ModelBase |
| _deferred = False |
| |
| def __init__(self, *args, **kwargs): |
| signals.pre_init.send(sender=self.__class__, args=args, kwargs=kwargs) |
| |
| # Set up the storage for instance state |
| self._state = ModelState() |
| |
| # There is a rather weird disparity here; if kwargs, it's set, then args |
| # overrides it. It should be one or the other; don't duplicate the work |
| # The reason for the kwargs check is that standard iterator passes in by |
| # args, and instantiation for iteration is 33% faster. |
| args_len = len(args) |
| if args_len > len(self._meta.fields): |
| # Daft, but matches old exception sans the err msg. |
| raise IndexError("Number of args exceeds number of fields") |
| |
| fields_iter = iter(self._meta.fields) |
| if not kwargs: |
| # The ordering of the izip calls matter - izip throws StopIteration |
| # when an iter throws it. So if the first iter throws it, the second |
| # is *not* consumed. We rely on this, so don't change the order |
| # without changing the logic. |
| for val, field in izip(args, fields_iter): |
| setattr(self, field.attname, val) |
| else: |
| # Slower, kwargs-ready version. |
| for val, field in izip(args, fields_iter): |
| setattr(self, field.attname, val) |
| kwargs.pop(field.name, None) |
| # Maintain compatibility with existing calls. |
| if isinstance(field.rel, ManyToOneRel): |
| kwargs.pop(field.attname, None) |
| |
| # Now we're left with the unprocessed fields that *must* come from |
| # keywords, or default. |
| |
| for field in fields_iter: |
| is_related_object = False |
| # This slightly odd construct is so that we can access any |
| # data-descriptor object (DeferredAttribute) without triggering its |
| # __get__ method. |
| if (field.attname not in kwargs and |
| isinstance(self.__class__.__dict__.get(field.attname), DeferredAttribute)): |
| # This field will be populated on request. |
| continue |
| if kwargs: |
| if isinstance(field.rel, ManyToOneRel): |
| try: |
| # Assume object instance was passed in. |
| rel_obj = kwargs.pop(field.name) |
| is_related_object = True |
| except KeyError: |
| try: |
| # Object instance wasn't passed in -- must be an ID. |
| val = kwargs.pop(field.attname) |
| except KeyError: |
| val = field.get_default() |
| else: |
| # Object instance was passed in. Special case: You can |
| # pass in "None" for related objects if it's allowed. |
| if rel_obj is None and field.null: |
| val = None |
| else: |
| try: |
| val = kwargs.pop(field.attname) |
| except KeyError: |
| # This is done with an exception rather than the |
| # default argument on pop because we don't want |
| # get_default() to be evaluated, and then not used. |
| # Refs #12057. |
| val = field.get_default() |
| else: |
| val = field.get_default() |
| if is_related_object: |
| # If we are passed a related instance, set it using the |
| # field.name instead of field.attname (e.g. "user" instead of |
| # "user_id") so that the object gets properly cached (and type |
| # checked) by the RelatedObjectDescriptor. |
| setattr(self, field.name, rel_obj) |
| else: |
| setattr(self, field.attname, val) |
| |
| if kwargs: |
| for prop in kwargs.keys(): |
| try: |
| if isinstance(getattr(self.__class__, prop), property): |
| setattr(self, prop, kwargs.pop(prop)) |
| except AttributeError: |
| pass |
| if kwargs: |
| raise TypeError("'%s' is an invalid keyword argument for this function" % kwargs.keys()[0]) |
| signals.post_init.send(sender=self.__class__, instance=self) |
| |
| def __repr__(self): |
| try: |
| u = unicode(self) |
| except (UnicodeEncodeError, UnicodeDecodeError): |
| u = '[Bad Unicode data]' |
| return smart_str(u'<%s: %s>' % (self.__class__.__name__, u)) |
| |
| def __str__(self): |
| if hasattr(self, '__unicode__'): |
| return force_unicode(self).encode('utf-8') |
| return '%s object' % self.__class__.__name__ |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self._get_pk_val() == other._get_pk_val() |
| |
| def __ne__(self, other): |
| return not self.__eq__(other) |
| |
| def __hash__(self): |
| return hash(self._get_pk_val()) |
| |
| def __reduce__(self): |
| """ |
| Provide pickling support. Normally, this just dispatches to Python's |
| standard handling. However, for models with deferred field loading, we |
| need to do things manually, as they're dynamically created classes and |
| only module-level classes can be pickled by the default path. |
| """ |
| data = self.__dict__ |
| model = self.__class__ |
| # The obvious thing to do here is to invoke super().__reduce__() |
| # for the non-deferred case. Don't do that. |
| # On Python 2.4, there is something wierd with __reduce__, |
| # and as a result, the super call will cause an infinite recursion. |
| # See #10547 and #12121. |
| defers = [] |
| pk_val = None |
| if self._deferred: |
| from django.db.models.query_utils import deferred_class_factory |
| factory = deferred_class_factory |
| for field in self._meta.fields: |
| if isinstance(self.__class__.__dict__.get(field.attname), |
| DeferredAttribute): |
| defers.append(field.attname) |
| if pk_val is None: |
| # The pk_val and model values are the same for all |
| # DeferredAttribute classes, so we only need to do this |
| # once. |
| obj = self.__class__.__dict__[field.attname] |
| model = obj.model_ref() |
| else: |
| factory = simple_class_factory |
| return (model_unpickle, (model, defers, factory), data) |
| |
| def _get_pk_val(self, meta=None): |
| if not meta: |
| meta = self._meta |
| return getattr(self, meta.pk.attname) |
| |
| def _set_pk_val(self, value): |
| return setattr(self, self._meta.pk.attname, value) |
| |
| pk = property(_get_pk_val, _set_pk_val) |
| |
| def serializable_value(self, field_name): |
| """ |
| Returns the value of the field name for this instance. If the field is |
| a foreign key, returns the id value, instead of the object. If there's |
| no Field object with this name on the model, the model attribute's |
| value is returned directly. |
| |
| Used to serialize a field's value (in the serializer, or form output, |
| for example). Normally, you would just access the attribute directly |
| and not use this method. |
| """ |
| try: |
| field = self._meta.get_field_by_name(field_name)[0] |
| except FieldDoesNotExist: |
| return getattr(self, field_name) |
| return getattr(self, field.attname) |
| |
| def save(self, force_insert=False, force_update=False, using=None): |
| """ |
| Saves the current instance. Override this in a subclass if you want to |
| control the saving process. |
| |
| The 'force_insert' and 'force_update' parameters can be used to insist |
| that the "save" must be an SQL insert or update (or equivalent for |
| non-SQL backends), respectively. Normally, they should not be set. |
| """ |
| if force_insert and force_update: |
| raise ValueError("Cannot force both insert and updating in model saving.") |
| self.save_base(using=using, force_insert=force_insert, force_update=force_update) |
| |
| save.alters_data = True |
| |
| def save_base(self, raw=False, cls=None, origin=None, force_insert=False, |
| force_update=False, using=None): |
| """ |
| Does the heavy-lifting involved in saving. Subclasses shouldn't need to |
| override this method. It's separate from save() in order to hide the |
| need for overrides of save() to pass around internal-only parameters |
| ('raw', 'cls', and 'origin'). |
| """ |
| using = using or router.db_for_write(self.__class__, instance=self) |
| connection = connections[using] |
| assert not (force_insert and force_update) |
| if cls is None: |
| cls = self.__class__ |
| meta = cls._meta |
| if not meta.proxy: |
| origin = cls |
| else: |
| meta = cls._meta |
| |
| if origin and not meta.auto_created: |
| signals.pre_save.send(sender=origin, instance=self, raw=raw, using=using) |
| |
| # If we are in a raw save, save the object exactly as presented. |
| # That means that we don't try to be smart about saving attributes |
| # that might have come from the parent class - we just save the |
| # attributes we have been given to the class we have been given. |
| # We also go through this process to defer the save of proxy objects |
| # to their actual underlying model. |
| if not raw or meta.proxy: |
| if meta.proxy: |
| org = cls |
| else: |
| org = None |
| for parent, field in meta.parents.items(): |
| # At this point, parent's primary key field may be unknown |
| # (for example, from administration form which doesn't fill |
| # this field). If so, fill it. |
| if field and getattr(self, parent._meta.pk.attname) is None and getattr(self, field.attname) is not None: |
| setattr(self, parent._meta.pk.attname, getattr(self, field.attname)) |
| |
| self.save_base(cls=parent, origin=org, using=using) |
| |
| if field: |
| setattr(self, field.attname, self._get_pk_val(parent._meta)) |
| if meta.proxy: |
| return |
| |
| if not meta.proxy: |
| non_pks = [f for f in meta.local_fields if not f.primary_key] |
| |
| # First, try an UPDATE. If that doesn't update anything, do an INSERT. |
| pk_val = self._get_pk_val(meta) |
| pk_set = pk_val is not None |
| record_exists = True |
| manager = cls._base_manager |
| if pk_set: |
| # Determine whether a record with the primary key already exists. |
| if (force_update or (not force_insert and |
| manager.using(using).filter(pk=pk_val).exists())): |
| # It does already exist, so do an UPDATE. |
| if force_update or non_pks: |
| values = [(f, None, (raw and getattr(self, f.attname) or f.pre_save(self, False))) for f in non_pks] |
| rows = manager.using(using).filter(pk=pk_val)._update(values) |
| if force_update and not rows: |
| raise DatabaseError("Forced update did not affect any rows.") |
| else: |
| record_exists = False |
| if not pk_set or not record_exists: |
| if meta.order_with_respect_to: |
| # If this is a model with an order_with_respect_to |
| # autopopulate the _order field |
| field = meta.order_with_respect_to |
| order_value = manager.using(using).filter(**{field.name: getattr(self, field.attname)}).count() |
| self._order = order_value |
| |
| if not pk_set: |
| if force_update: |
| raise ValueError("Cannot force an update in save() with no primary key.") |
| values = [(f, f.get_db_prep_save(raw and getattr(self, f.attname) or f.pre_save(self, True), connection=connection)) |
| for f in meta.local_fields if not isinstance(f, AutoField)] |
| else: |
| values = [(f, f.get_db_prep_save(raw and getattr(self, f.attname) or f.pre_save(self, True), connection=connection)) |
| for f in meta.local_fields] |
| |
| record_exists = False |
| |
| update_pk = bool(meta.has_auto_field and not pk_set) |
| if values: |
| # Create a new record. |
| result = manager._insert(values, return_id=update_pk, using=using) |
| else: |
| # Create a new record with defaults for everything. |
| result = manager._insert([(meta.pk, connection.ops.pk_default_value())], return_id=update_pk, raw_values=True, using=using) |
| |
| if update_pk: |
| setattr(self, meta.pk.attname, result) |
| transaction.commit_unless_managed(using=using) |
| |
| # Store the database on which the object was saved |
| self._state.db = using |
| # Once saved, this is no longer a to-be-added instance. |
| self._state.adding = False |
| |
| # Signal that the save is complete |
| if origin and not meta.auto_created: |
| signals.post_save.send(sender=origin, instance=self, |
| created=(not record_exists), raw=raw, using=using) |
| |
| |
| save_base.alters_data = True |
| |
| def delete(self, using=None): |
| using = using or router.db_for_write(self.__class__, instance=self) |
| assert self._get_pk_val() is not None, "%s object can't be deleted because its %s attribute is set to None." % (self._meta.object_name, self._meta.pk.attname) |
| |
| collector = Collector(using=using) |
| collector.collect([self]) |
| collector.delete() |
| |
| delete.alters_data = True |
| |
| def _get_FIELD_display(self, field): |
| value = getattr(self, field.attname) |
| return force_unicode(dict(field.flatchoices).get(value, value), strings_only=True) |
| |
| def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs): |
| if not self.pk: |
| raise ValueError("get_next/get_previous cannot be used on unsaved objects.") |
| op = is_next and 'gt' or 'lt' |
| order = not is_next and '-' or '' |
| param = smart_str(getattr(self, field.attname)) |
| q = Q(**{'%s__%s' % (field.name, op): param}) |
| q = q|Q(**{field.name: param, 'pk__%s' % op: self.pk}) |
| qs = self.__class__._default_manager.using(self._state.db).filter(**kwargs).filter(q).order_by('%s%s' % (order, field.name), '%spk' % order) |
| try: |
| return qs[0] |
| except IndexError: |
| raise self.DoesNotExist("%s matching query does not exist." % self.__class__._meta.object_name) |
| |
| def _get_next_or_previous_in_order(self, is_next): |
| cachename = "__%s_order_cache" % is_next |
| if not hasattr(self, cachename): |
| op = is_next and 'gt' or 'lt' |
| order = not is_next and '-_order' or '_order' |
| order_field = self._meta.order_with_respect_to |
| obj = self._default_manager.filter(**{ |
| order_field.name: getattr(self, order_field.attname) |
| }).filter(**{ |
| '_order__%s' % op: self._default_manager.values('_order').filter(**{ |
| self._meta.pk.name: self.pk |
| }) |
| }).order_by(order)[:1].get() |
| setattr(self, cachename, obj) |
| return getattr(self, cachename) |
| |
| def prepare_database_save(self, unused): |
| return self.pk |
| |
| def clean(self): |
| """ |
| Hook for doing any extra model-wide validation after clean() has been |
| called on every field by self.clean_fields. Any ValidationError raised |
| by this method will not be associated with a particular field; it will |
| have a special-case association with the field defined by NON_FIELD_ERRORS. |
| """ |
| pass |
| |
| def validate_unique(self, exclude=None): |
| """ |
| Checks unique constraints on the model and raises ``ValidationError`` |
| if any failed. |
| """ |
| unique_checks, date_checks = self._get_unique_checks(exclude=exclude) |
| |
| errors = self._perform_unique_checks(unique_checks) |
| date_errors = self._perform_date_checks(date_checks) |
| |
| for k, v in date_errors.items(): |
| errors.setdefault(k, []).extend(v) |
| |
| if errors: |
| raise ValidationError(errors) |
| |
| def _get_unique_checks(self, exclude=None): |
| """ |
| Gather a list of checks to perform. Since validate_unique could be |
| called from a ModelForm, some fields may have been excluded; we can't |
| perform a unique check on a model that is missing fields involved |
| in that check. |
| Fields that did not validate should also be exluded, but they need |
| to be passed in via the exclude argument. |
| """ |
| if exclude is None: |
| exclude = [] |
| unique_checks = [] |
| |
| unique_togethers = [(self.__class__, self._meta.unique_together)] |
| for parent_class in self._meta.parents.keys(): |
| if parent_class._meta.unique_together: |
| unique_togethers.append((parent_class, parent_class._meta.unique_together)) |
| |
| for model_class, unique_together in unique_togethers: |
| for check in unique_together: |
| for name in check: |
| # If this is an excluded field, don't add this check. |
| if name in exclude: |
| break |
| else: |
| unique_checks.append((model_class, tuple(check))) |
| |
| # These are checks for the unique_for_<date/year/month>. |
| date_checks = [] |
| |
| # Gather a list of checks for fields declared as unique and add them to |
| # the list of checks. |
| |
| fields_with_class = [(self.__class__, self._meta.local_fields)] |
| for parent_class in self._meta.parents.keys(): |
| fields_with_class.append((parent_class, parent_class._meta.local_fields)) |
| |
| for model_class, fields in fields_with_class: |
| for f in fields: |
| name = f.name |
| if name in exclude: |
| continue |
| if f.unique: |
| unique_checks.append((model_class, (name,))) |
| if f.unique_for_date and f.unique_for_date not in exclude: |
| date_checks.append((model_class, 'date', name, f.unique_for_date)) |
| if f.unique_for_year and f.unique_for_year not in exclude: |
| date_checks.append((model_class, 'year', name, f.unique_for_year)) |
| if f.unique_for_month and f.unique_for_month not in exclude: |
| date_checks.append((model_class, 'month', name, f.unique_for_month)) |
| return unique_checks, date_checks |
| |
| def _perform_unique_checks(self, unique_checks): |
| errors = {} |
| |
| for model_class, unique_check in unique_checks: |
| # Try to look up an existing object with the same values as this |
| # object's values for all the unique field. |
| |
| lookup_kwargs = {} |
| for field_name in unique_check: |
| f = self._meta.get_field(field_name) |
| lookup_value = getattr(self, f.attname) |
| if lookup_value is None: |
| # no value, skip the lookup |
| continue |
| if f.primary_key and not self._state.adding: |
| # no need to check for unique primary key when editing |
| continue |
| lookup_kwargs[str(field_name)] = lookup_value |
| |
| # some fields were skipped, no reason to do the check |
| if len(unique_check) != len(lookup_kwargs.keys()): |
| continue |
| |
| qs = model_class._default_manager.filter(**lookup_kwargs) |
| |
| # Exclude the current object from the query if we are editing an |
| # instance (as opposed to creating a new one) |
| if not self._state.adding and self.pk is not None: |
| qs = qs.exclude(pk=self.pk) |
| |
| if qs.exists(): |
| if len(unique_check) == 1: |
| key = unique_check[0] |
| else: |
| key = NON_FIELD_ERRORS |
| errors.setdefault(key, []).append(self.unique_error_message(model_class, unique_check)) |
| |
| return errors |
| |
| def _perform_date_checks(self, date_checks): |
| errors = {} |
| for model_class, lookup_type, field, unique_for in date_checks: |
| lookup_kwargs = {} |
| # there's a ticket to add a date lookup, we can remove this special |
| # case if that makes it's way in |
| date = getattr(self, unique_for) |
| if lookup_type == 'date': |
| lookup_kwargs['%s__day' % unique_for] = date.day |
| lookup_kwargs['%s__month' % unique_for] = date.month |
| lookup_kwargs['%s__year' % unique_for] = date.year |
| else: |
| lookup_kwargs['%s__%s' % (unique_for, lookup_type)] = getattr(date, lookup_type) |
| lookup_kwargs[field] = getattr(self, field) |
| |
| qs = model_class._default_manager.filter(**lookup_kwargs) |
| # Exclude the current object from the query if we are editing an |
| # instance (as opposed to creating a new one) |
| if not self._state.adding and self.pk is not None: |
| qs = qs.exclude(pk=self.pk) |
| |
| if qs.exists(): |
| errors.setdefault(field, []).append( |
| self.date_error_message(lookup_type, field, unique_for) |
| ) |
| return errors |
| |
| def date_error_message(self, lookup_type, field, unique_for): |
| opts = self._meta |
| return _(u"%(field_name)s must be unique for %(date_field)s %(lookup)s.") % { |
| 'field_name': unicode(capfirst(opts.get_field(field).verbose_name)), |
| 'date_field': unicode(capfirst(opts.get_field(unique_for).verbose_name)), |
| 'lookup': lookup_type, |
| } |
| |
| def unique_error_message(self, model_class, unique_check): |
| opts = model_class._meta |
| model_name = capfirst(opts.verbose_name) |
| |
| # A unique field |
| if len(unique_check) == 1: |
| field_name = unique_check[0] |
| field_label = capfirst(opts.get_field(field_name).verbose_name) |
| # Insert the error into the error dict, very sneaky |
| return _(u"%(model_name)s with this %(field_label)s already exists.") % { |
| 'model_name': unicode(model_name), |
| 'field_label': unicode(field_label) |
| } |
| # unique_together |
| else: |
| field_labels = map(lambda f: capfirst(opts.get_field(f).verbose_name), unique_check) |
| field_labels = get_text_list(field_labels, _('and')) |
| return _(u"%(model_name)s with this %(field_label)s already exists.") % { |
| 'model_name': unicode(model_name), |
| 'field_label': unicode(field_labels) |
| } |
| |
| def full_clean(self, exclude=None): |
| """ |
| Calls clean_fields, clean, and validate_unique, on the model, |
| and raises a ``ValidationError`` for any errors that occured. |
| """ |
| errors = {} |
| if exclude is None: |
| exclude = [] |
| |
| try: |
| self.clean_fields(exclude=exclude) |
| except ValidationError, e: |
| errors = e.update_error_dict(errors) |
| |
| # Form.clean() is run even if other validation fails, so do the |
| # same with Model.clean() for consistency. |
| try: |
| self.clean() |
| except ValidationError, e: |
| errors = e.update_error_dict(errors) |
| |
| # Run unique checks, but only for fields that passed validation. |
| for name in errors.keys(): |
| if name != NON_FIELD_ERRORS and name not in exclude: |
| exclude.append(name) |
| try: |
| self.validate_unique(exclude=exclude) |
| except ValidationError, e: |
| errors = e.update_error_dict(errors) |
| |
| if errors: |
| raise ValidationError(errors) |
| |
| def clean_fields(self, exclude=None): |
| """ |
| Cleans all fields and raises a ValidationError containing message_dict |
| of all validation errors if any occur. |
| """ |
| if exclude is None: |
| exclude = [] |
| |
| errors = {} |
| for f in self._meta.fields: |
| if f.name in exclude: |
| continue |
| # Skip validation for empty fields with blank=True. The developer |
| # is responsible for making sure they have a valid value. |
| raw_value = getattr(self, f.attname) |
| if f.blank and raw_value in validators.EMPTY_VALUES: |
| continue |
| try: |
| setattr(self, f.attname, f.clean(raw_value, self)) |
| except ValidationError, e: |
| errors[f.name] = e.messages |
| |
| if errors: |
| raise ValidationError(errors) |
| |
| |
| ############################################ |
| # HELPER FUNCTIONS (CURRIED MODEL METHODS) # |
| ############################################ |
| |
| # ORDERING METHODS ######################### |
| |
| def method_set_order(ordered_obj, self, id_list, using=None): |
| if using is None: |
| using = DEFAULT_DB_ALIAS |
| rel_val = getattr(self, ordered_obj._meta.order_with_respect_to.rel.field_name) |
| order_name = ordered_obj._meta.order_with_respect_to.name |
| # FIXME: It would be nice if there was an "update many" version of update |
| # for situations like this. |
| for i, j in enumerate(id_list): |
| ordered_obj.objects.filter(**{'pk': j, order_name: rel_val}).update(_order=i) |
| transaction.commit_unless_managed(using=using) |
| |
| |
| def method_get_order(ordered_obj, self): |
| rel_val = getattr(self, ordered_obj._meta.order_with_respect_to.rel.field_name) |
| order_name = ordered_obj._meta.order_with_respect_to.name |
| pk_name = ordered_obj._meta.pk.name |
| return [r[pk_name] for r in |
| ordered_obj.objects.filter(**{order_name: rel_val}).values(pk_name)] |
| |
| |
| ############################################## |
| # HELPER FUNCTIONS (CURRIED MODEL FUNCTIONS) # |
| ############################################## |
| |
| def get_absolute_url(opts, func, self, *args, **kwargs): |
| return settings.ABSOLUTE_URL_OVERRIDES.get('%s.%s' % (opts.app_label, opts.module_name), func)(self, *args, **kwargs) |
| |
| |
| ######## |
| # MISC # |
| ######## |
| |
| class Empty(object): |
| pass |
| |
| def simple_class_factory(model, attrs): |
| """Used to unpickle Models without deferred fields. |
| |
| We need to do this the hard way, rather than just using |
| the default __reduce__ implementation, because of a |
| __deepcopy__ problem in Python 2.4 |
| """ |
| return model |
| |
| def model_unpickle(model, attrs, factory): |
| """ |
| Used to unpickle Model subclasses with deferred fields. |
| """ |
| cls = factory(model, attrs) |
| return cls.__new__(cls) |
| model_unpickle.__safe_for_unpickle__ = True |
| |
| if sys.version_info < (2, 5): |
| # Prior to Python 2.5, Exception was an old-style class |
| def subclass_exception(name, parents, unused): |
| return types.ClassType(name, parents, {}) |
| else: |
| def subclass_exception(name, parents, module): |
| return type(name, parents, {'__module__': module}) |
