py_tasks_melange: comparison app/django/contrib/auth/models.py

equal deleted inserted replaced

-:6641e941ef1e
+:ff1a9aa48cfd
+import datetime
+import urllib
 from django.contrib import auth
-from django.core import validators
 from django.core.exceptions import ImproperlyConfigured
 from django.db import models
 from django.db.models.manager import EmptyManager
 from django.contrib.contenttypes.models import ContentType
 from django.utils.encoding import smart_str
+from django.utils.hashcompat import md5_constructor, sha_constructor
 from django.utils.translation import ugettext_lazy as _
-import datetime
-import urllib
 UNUSABLE_PASSWORD = '!' # This will never be a valid hash
 try:
 set
 try:
 import crypt
 except ImportError:
 raise ValueError('"crypt" password algorithm not supported in this environment')
 return crypt.crypt(raw_password, salt)
-# The rest of the supported algorithms are supported by hashlib, but
-# hashlib is only available in Python 2.5.
+if algorithm == 'md5':
-try:
+return md5_constructor(salt + raw_password).hexdigest()
-import hashlib
+elif algorithm == 'sha1':
-except ImportError:
+return sha_constructor(salt + raw_password).hexdigest()
-if algorithm == 'md5':
-import md5
-return md5.new(salt + raw_password).hexdigest()
-elif algorithm == 'sha1':
-import sha
-return sha.new(salt + raw_password).hexdigest()
-else:
-if algorithm == 'md5':
-return hashlib.md5(salt + raw_password).hexdigest()
-elif algorithm == 'sha1':
-return hashlib.sha1(salt + raw_password).hexdigest()
 raise ValueError("Got unknown password algorithm type in password.")
 def check_password(raw_password, enc_password):
 """
 Returns a boolean of whether the raw_password was correct. Handles
 class Meta:
 verbose_name = _('permission')
 verbose_name_plural = _('permissions')
 unique_together = (('content_type', 'codename'),)
-ordering = ('content_type', 'codename')
+ordering = ('content_type__app_label', 'codename')
 def __unicode__(self):
-return u"%s | %s | %s" % (self.content_type.app_label, self.content_type, self.name)
+return u"%s | %s | %s" % (
+unicode(self.content_type.app_label),
+unicode(self.content_type),
+unicode(self.name))
 class Group(models.Model):
 """Groups are a generic way of categorizing users to apply permissions, or some other label, to those users. A user can belong to any number of groups.
 A user in a group automatically has all the permissions granted to that group. For example, if the group Site editors has the permission can_edit_home_page, any user in that group will have that permission.
 Beyond permissions, groups are a convenient way to categorize users to apply some label, or extended functionality, to them. For example, you could create a group 'Special users', and you could write code that would do special things to those users -- such as giving them access to a members-only portion of your site, or sending them members-only e-mail messages.
 """
 name = models.CharField(_('name'), max_length=80, unique=True)
-permissions = models.ManyToManyField(Permission, verbose_name=_('permissions'), blank=True, filter_interface=models.HORIZONTAL)
+permissions = models.ManyToManyField(Permission, verbose_name=_('permissions'), blank=True)
 class Meta:
 verbose_name = _('group')
 verbose_name_plural = _('groups')
-ordering = ('name',)
-class Admin:
-search_fields = ('name',)
 def __unicode__(self):
 return self.name
 class UserManager(models.Manager):
 else:
 user.set_unusable_password()
 user.save()
 return user
+def create_superuser(self, username, email, password):
+u = self.create_user(username, email, password)
+u.is_staff = True
+u.is_active = True
+u.is_superuser = True
+u.save()
 def make_random_password(self, length=10, allowed_chars='abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'):
 "Generates a random password with the given length and given allowed_chars"
 # Note that default value of allowed_chars does not have "I" or letters
 # that look like it -- just to avoid confusion.
 from random import choice
 class User(models.Model):
 """Users within the Django authentication system are represented by this model.
 Username and password are required. Other fields are optional.
 """
-username = models.CharField(_('username'), max_length=30, unique=True, validator_list=[validators.isAlphaNumeric], help_text=_("Required. 30 characters or fewer. Alphanumeric characters only (letters, digits and underscores)."))
+username = models.CharField(_('username'), max_length=30, unique=True, help_text=_("Required. 30 characters or fewer. Alphanumeric characters only (letters, digits and underscores)."))
 first_name = models.CharField(_('first name'), max_length=30, blank=True)
 last_name = models.CharField(_('last name'), max_length=30, blank=True)
 email = models.EmailField(_('e-mail address'), blank=True)
 password = models.CharField(_('password'), max_length=128, help_text=_("Use '[algo]$[salt]$[hexdigest]' or use the <a href=\"password/\">change password form</a>."))
 is_staff = models.BooleanField(_('staff status'), default=False, help_text=_("Designates whether the user can log into this admin site."))
 is_superuser = models.BooleanField(_('superuser status'), default=False, help_text=_("Designates that this user has all permissions without explicitly assigning them."))
 last_login = models.DateTimeField(_('last login'), default=datetime.datetime.now)
 date_joined = models.DateTimeField(_('date joined'), default=datetime.datetime.now)
 groups = models.ManyToManyField(Group, verbose_name=_('groups'), blank=True,
 help_text=_("In addition to the permissions manually assigned, this user will also get all permissions granted to each group he/she is in."))
-user_permissions = models.ManyToManyField(Permission, verbose_name=_('user permissions'), blank=True, filter_interface=models.HORIZONTAL)
+user_permissions = models.ManyToManyField(Permission, verbose_name=_('user permissions'), blank=True)
 objects = UserManager()
 class Meta:
 verbose_name = _('user')
 verbose_name_plural = _('users')
-ordering = ('username',)
-class Admin:
-fields = (
-(None, {'fields': ('username', 'password')}),
-(_('Personal info'), {'fields': ('first_name', 'last_name', 'email')}),
-(_('Permissions'), {'fields': ('is_staff', 'is_active', 'is_superuser', 'user_permissions')}),
-(_('Important dates'), {'fields': ('last_login', 'date_joined')}),
-(_('Groups'), {'fields': ('groups',)}),
-)
-list_display = ('username', 'email', 'first_name', 'last_name', 'is_staff')
-list_filter = ('is_staff', 'is_superuser')
-search_fields = ('username', 'first_name', 'last_name', 'email')
 def __unicode__(self):
 return self.username
 def get_absolute_url(self):
 Returns site-specific profile for this user. Raises
 SiteProfileNotAvailable if this site does not allow profiles.
 """
 if not hasattr(self, '_profile_cache'):
 from django.conf import settings
-if not settings.AUTH_PROFILE_MODULE:
+if not getattr(settings, 'AUTH_PROFILE_MODULE', False):
 raise SiteProfileNotAvailable
 try:
 app_label, model_name = settings.AUTH_PROFILE_MODULE.split('.')
 model = models.get_model(app_label, model_name)
 self._profile_cache = model._default_manager.get(user__id__exact=self.id)
+self._profile_cache.user = self
 except (ImportError, ImproperlyConfigured):
 raise SiteProfileNotAvailable
 return self._profile_cache
 class Message(models.Model):
 user_permissions = property(_get_user_permissions)
 def has_perm(self, perm):
 return False
+def has_perms(self, perm_list):
+return False
 def has_module_perms(self, module):
 return False
 def get_and_delete_messages(self):
 return []

changeset 323	ff1a9aa48cfd
parent 54	03e267d67478