Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

220 lines (196 sloc) 9.578 kb
from django.core import meta, validators
from django.models import core
from django.utils.translation import gettext_lazy as _
class Permission(meta.Model):
name = meta.CharField(_('name'), maxlength=50)
package = meta.ForeignKey(core.Package, db_column='package')
codename = meta.CharField(_('codename'), maxlength=100)
class META:
verbose_name = _('Permission')
verbose_name_plural = _('Permissions')
unique_together = (('package', 'codename'),)
ordering = ('package', 'codename')
def __repr__(self):
return "%s | %s" % (self.package_id, self.name)
class Group(meta.Model):
name = meta.CharField(_('name'), maxlength=80, unique=True)
permissions = meta.ManyToManyField(Permission, blank=True, filter_interface=meta.HORIZONTAL)
class META:
verbose_name = _('Group')
verbose_name_plural = _('Groups')
ordering = ('name',)
admin = meta.Admin(
search_fields = ('name',),
)
def __repr__(self):
return self.name
class User(meta.Model):
username = meta.CharField(_('username'), maxlength=30, unique=True, validator_list=[validators.isAlphaNumeric])
first_name = meta.CharField(_('first name'), maxlength=30, blank=True)
last_name = meta.CharField(_('last name'), maxlength=30, blank=True)
email = meta.EmailField(_('e-mail address'), blank=True)
password = meta.CharField(_('password'), maxlength=128, help_text=_("Use '[algo]$[salt]$[hexdigest]'"))
is_staff = meta.BooleanField(_('staff status'), help_text=_("Designates whether the user can log into this admin site."))
is_active = meta.BooleanField(_('active'), default=True)
is_superuser = meta.BooleanField(_('superuser status'))
last_login = meta.DateTimeField(_('last login'), default=meta.LazyDate())
date_joined = meta.DateTimeField(_('date joined'), default=meta.LazyDate())
groups = meta.ManyToManyField(Group, 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 = meta.ManyToManyField(Permission, blank=True, filter_interface=meta.HORIZONTAL)
class META:
verbose_name = _('User')
verbose_name_plural = _('Users')
module_constants = {
'SESSION_KEY': '_auth_user_id',
}
ordering = ('username',)
exceptions = ('SiteProfileNotAvailable',)
admin = meta.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 __repr__(self):
return self.username
def get_absolute_url(self):
return "/users/%s/" % self.username
def is_anonymous(self):
return False
def get_full_name(self):
full_name = '%s %s' % (self.first_name, self.last_name)
return full_name.strip()
def set_password(self, raw_password):
import sha, random
algo = 'sha1'
salt = sha.new(str(random.random())).hexdigest()[:5]
hsh = sha.new(salt+raw_password).hexdigest()
self.password = '%s$%s$%s' % (algo, salt, hsh)
def check_password(self, raw_password):
"""
Returns a boolean of whether the raw_password was correct. Handles
encryption formats behind the scenes.
"""
# Backwards-compatibility check. Older passwords won't include the
# algorithm or salt.
if '$' not in self.password:
import md5
is_correct = (self.password == md5.new(raw_password).hexdigest())
if is_correct:
# Convert the password to the new, more secure format.
self.set_password(raw_password)
self.save()
return is_correct
algo, salt, hsh = self.password.split('$')
if algo == 'md5':
import md5
return hsh == md5.new(salt+raw_password).hexdigest()
elif algo == 'sha1':
import sha
return hsh == sha.new(salt+raw_password).hexdigest()
raise ValueError, "Got unknown password algorithm type in password."
def get_group_permissions(self):
"Returns a list of permission strings that this user has through his/her groups."
if not hasattr(self, '_group_perm_cache'):
import sets
cursor = db.cursor()
# The SQL below works out to the following, after DB quoting:
# cursor.execute("""
# SELECT p.package, p.codename
# FROM auth_permissions p, auth_groups_permissions gp, auth_users_groups ug
# WHERE p.id = gp.permission_id
# AND gp.group_id = ug.group_id
# AND ug.user_id = %s""", [self.id])
sql = """
SELECT p.%s, p.%s
FROM %s p, %s gp, %s ug
WHERE p.%s = gp.%s
AND gp.%s = ug.%s
AND ug.%s = %%s""" % (
db.quote_name('package'), db.quote_name('codename'),
db.quote_name('auth_permissions'), db.quote_name('auth_groups_permissions'),
db.quote_name('auth_users_groups'), db.quote_name('id'),
db.quote_name('permission_id'), db.quote_name('group_id'),
db.quote_name('group_id'), db.quote_name('user_id'))
cursor.execute(sql, [self.id])
self._group_perm_cache = sets.Set(["%s.%s" % (row[0], row[1]) for row in cursor.fetchall()])
return self._group_perm_cache
def get_all_permissions(self):
if not hasattr(self, '_perm_cache'):
import sets
self._perm_cache = sets.Set(["%s.%s" % (p.package_id, p.codename) for p in self.get_permission_list()])
self._perm_cache.update(self.get_group_permissions())
return self._perm_cache
def has_perm(self, perm):
"Returns True if the user has the specified permission."
if not self.is_active:
return False
if self.is_superuser:
return True
return perm in self.get_all_permissions()
def has_perms(self, perm_list):
"Returns True if the user has each of the specified permissions."
for perm in perm_list:
if not self.has_perm(perm):
return False
return True
def has_module_perms(self, package_name):
"Returns True if the user has any permissions in the given package."
if self.is_superuser:
return True
return bool(len([p for p in self.get_all_permissions() if p[:p.index('.')] == package_name]))
def get_and_delete_messages(self):
messages = []
for m in self.get_message_list():
messages.append(m.message)
m.delete()
return messages
def email_user(self, subject, message, from_email=None):
"Sends an e-mail to this User."
from django.core.mail import send_mail
send_mail(subject, message, from_email, [self.email])
def get_profile(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.settings import AUTH_PROFILE_MODULE
if not AUTH_PROFILE_MODULE:
raise SiteProfileNotAvailable
try:
app, mod = AUTH_PROFILE_MODULE.split('.')
module = __import__('ellington.%s.apps.%s' % (app, mod), [], [], [''])
self._profile_cache = module.get_object(user_id=self.id)
except ImportError:
try:
module = __import__('django.models.%s' % AUTH_PROFILE_MODULE, [], [], [''])
self._profile_cache = module.get_object(user__id__exact=self.id)
except ImportError:
raise SiteProfileNotAvailable
return self._profile_cache
def _module_create_user(username, email, password):
"Creates and saves a User with the given username, e-mail and password."
now = datetime.datetime.now()
user = User(None, username, '', '', email.strip().lower(), 'placeholder', False, True, False, now, now)
user.set_password(password)
user.save()
return user
def _module_make_random_password(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
return ''.join([choice(allowed_chars) for i in range(length)])
class Message(meta.Model):
user = meta.ForeignKey(User)
message = meta.TextField(_('Message'))
def __repr__(self):
return self.message
Jump to Line
Something went wrong with that request. Please try again.