""" Django Extensions additional model fields """ from django.template.defaultfilters import slugify from django.db.models import DateTimeField, CharField, SlugField import datetime import re try: import uuid except ImportError: from django_extensions.utils import uuid class AutoSlugField(SlugField): """ AutoSlugField By default, sets editable=False, blank=True. Required arguments: populate_from Specifies which field or list of fields the slug is populated from. Optional arguments: separator Defines the used separator (default: '-') overwrite If set to True, overwrites the slug on every save (default: False) Inspired by SmileyChris' Unique Slugify snippet: http://www.djangosnippets.org/snippets/690/ """ def __init__(self, *args, **kwargs): kwargs.setdefault('blank', True) kwargs.setdefault('editable', False) populate_from = kwargs.pop('populate_from', None) if populate_from is None: raise ValueError("missing 'populate_from' argument") else: self._populate_from = populate_from self.separator = kwargs.pop('separator', u'-') self.overwrite = kwargs.pop('overwrite', False) super(AutoSlugField, self).__init__(*args, **kwargs) def _slug_strip(self, value): """ Cleans up a slug by removing slug separator characters that occur at the beginning or end of a slug. If an alternate separator is used, it will also replace any instances of the default '-' separator with the new separator. """ re_sep = '(?:-|%s)' % re.escape(self.separator) value = re.sub('%s+' % re_sep, self.separator, value) return re.sub(r'^%s+|%s+$' % (re_sep, re_sep), '', value) def slugify_func(self, content): return slugify(content) def create_slug(self, model_instance, add): # get fields to populate from and slug field to set if not isinstance(self._populate_from, (list, tuple)): self._populate_from = (self._populate_from, ) slug_field = model_instance._meta.get_field(self.attname) if add or self.overwrite: # slugify the original field content and set next step to 2 slug_for_field = lambda field: self.slugify_func(getattr(model_instance, field)) slug = self.separator.join(map(slug_for_field, self._populate_from)) next = 2 else: # get slug from the current model instance and calculate next # step from its number, clean-up slug = self._slug_strip(getattr(model_instance, self.attname)) next = slug.split(self.separator)[-1] if next.isdigit(): slug = self.separator.join(slug.split(self.separator)[:-1]) next = int(next) else: next = 2 # strip slug depending on max_length attribute of the slug field # and clean-up slug_len = slug_field.max_length if slug_len: slug = slug[:slug_len] slug = self._slug_strip(slug) original_slug = slug # exclude the current model instance from the queryset used in finding # the next valid slug queryset = model_instance.__class__._default_manager.all() if model_instance.pk: queryset = queryset.exclude(pk=model_instance.pk) # form a kwarg dict used to impliment any unique_together contraints kwargs = {} for params in model_instance._meta.unique_together: if self.attname in params: for param in params: kwargs[param] = getattr(model_instance, param, None) kwargs[self.attname] = slug # increases the number while searching for the next valid slug # depending on the given slug, clean-up while not slug or queryset.filter(**kwargs): slug = original_slug end = '%s%s' % (self.separator, next) end_len = len(end) if slug_len and len(slug)+end_len > slug_len: slug = slug[:slug_len-end_len] slug = self._slug_strip(slug) slug = '%s%s' % (slug, end) kwargs[self.attname] = slug next += 1 return slug def pre_save(self, model_instance, add): value = unicode(self.create_slug(model_instance, add)) setattr(model_instance, self.attname, value) return value def get_internal_type(self): return "SlugField" def south_field_triple(self): "Returns a suitable description of this field for South." # We'll just introspect the _actual_ field. from south.modelsinspector import introspector field_class = "django.db.models.fields.SlugField" args, kwargs = introspector(self) # That's our definition! return (field_class, args, kwargs) class CreationDateTimeField(DateTimeField): """ CreationDateTimeField By default, sets editable=False, blank=True, default=datetime.now """ def __init__(self, *args, **kwargs): kwargs.setdefault('editable', False) kwargs.setdefault('blank', True) kwargs.setdefault('default', datetime.datetime.now) DateTimeField.__init__(self, *args, **kwargs) def get_internal_type(self): return "DateTimeField" def south_field_triple(self): "Returns a suitable description of this field for South." # We'll just introspect ourselves, since we inherit. from south.modelsinspector import introspector field_class = "django.db.models.fields.DateTimeField" args, kwargs = introspector(self) return (field_class, args, kwargs) class ModificationDateTimeField(CreationDateTimeField): """ ModificationDateTimeField By default, sets editable=False, blank=True, default=datetime.now Sets value to datetime.now() on each save of the model. """ def pre_save(self, model, add): value = datetime.datetime.now() setattr(model, self.attname, value) return value def get_internal_type(self): return "DateTimeField" def south_field_triple(self): "Returns a suitable description of this field for South." # We'll just introspect ourselves, since we inherit. from south.modelsinspector import introspector field_class = "django.db.models.fields.DateTimeField" args, kwargs = introspector(self) return (field_class, args, kwargs) class UUIDVersionError(Exception): pass class UUIDField(CharField): """ UUIDField By default uses UUID version 1 (generate from host ID, sequence number and current time) The field support all uuid versions which are natively supported by the uuid python module. For more information see: http://docs.python.org/lib/module-uuid.html """ def __init__(self, verbose_name=None, name=None, auto=True, version=1, node=None, clock_seq=None, namespace=None, **kwargs): kwargs['max_length'] = 36 if auto: kwargs['blank'] = True kwargs.setdefault('editable', False) self.auto = auto self.version = version if version==1: self.node, self.clock_seq = node, clock_seq elif version==3 or version==5: self.namespace, self.name = namespace, name CharField.__init__(self, verbose_name, name, **kwargs) def get_internal_type(self): return CharField.__name__ def create_uuid(self): if not self.version or self.version==4: return uuid.uuid4() elif self.version==1: return uuid.uuid1(self.node, self.clock_seq) elif self.version==2: raise UUIDVersionError("UUID version 2 is not supported.") elif self.version==3: return uuid.uuid3(self.namespace, self.name) elif self.version==5: return uuid.uuid5(self.namespace, self.name) else: raise UUIDVersionError("UUID version %s is not valid." % self.version) def pre_save(self, model_instance, add): if self.auto and add: value = unicode(self.create_uuid()) setattr(model_instance, self.attname, value) return value else: value = super(UUIDField, self).pre_save(model_instance, add) if self.auto and not value: value = unicode(self.create_uuid()) setattr(model_instance, self.attname, value) return value def south_field_triple(self): "Returns a suitable description of this field for South." # We'll just introspect the _actual_ field. from south.modelsinspector import introspector field_class = "django.db.models.fields.CharField" args, kwargs = introspector(self) # That's our definition! return (field_class, args, kwargs)