mirror of
https://github.com/haiwen/seahub.git
synced 2025-09-05 00:43:53 +00:00
Remove auth and site from app, clean auth modual
This commit is contained in:
xiez
@@ -4,7 +4,8 @@ from django.utils.hashcompat import md5_constructor, sha_constructor
|
||||
from django.utils.translation import ugettext_lazy as _
|
||||
from django.conf import settings
|
||||
|
||||
from auth.models import User, Permission, get_hexdigest
|
||||
from auth.models import get_hexdigest, check_password
|
||||
|
||||
from auth import authenticate, login
|
||||
|
||||
from django.contrib.sites.models import RequestSite
|
||||
@@ -39,7 +40,6 @@ def convert_to_ccnetuser(emailuser):
|
||||
class CcnetUser(object):
|
||||
is_staff = False
|
||||
is_active = False
|
||||
user_permissions = Permission()
|
||||
objects = UserManager()
|
||||
|
||||
def __init__(self, username, raw_password):
|
||||
@@ -54,6 +54,10 @@ class CcnetUser(object):
|
||||
return ccnet_rpc.validate_emailuser(email, raw_password)
|
||||
|
||||
def is_authenticated(self):
|
||||
"""
|
||||
Always return True. This is a way to tell if the user has been
|
||||
authenticated in templates.
|
||||
"""
|
||||
return True
|
||||
|
||||
def is_anonymous(self):
|
||||
@@ -111,33 +115,6 @@ class CcnetUser(object):
|
||||
from django.core.mail import send_mail
|
||||
send_mail(subject, message, from_email, [self.username])
|
||||
|
||||
def has_perm(self, perm, obj=None):
|
||||
"""
|
||||
Returns True if the user has the specified permission. This method
|
||||
queries all available auth backends, but returns immediately if any
|
||||
backend returns True. Thus, a user who has permission from a single
|
||||
auth backend is assumed to have permission in general. If an object
|
||||
is provided, permissions for this specific object are checked.
|
||||
"""
|
||||
|
||||
# Active superusers have all permissions.
|
||||
if self.is_active and self.is_superuser:
|
||||
return True
|
||||
|
||||
# Otherwise we need to check the backends.
|
||||
return _user_has_perm(self, perm, obj)
|
||||
|
||||
def has_module_perms(self, app_label):
|
||||
"""
|
||||
Returns True if the user has any permissions in the given app
|
||||
label. Uses pretty much the same logic as has_perm, above.
|
||||
"""
|
||||
# Active superusers have all permissions.
|
||||
if self.is_active and self.is_superuser:
|
||||
return True
|
||||
|
||||
from auth.models import _user_has_module_perms
|
||||
return _user_has_module_perms(self, app_label)
|
||||
|
||||
class RegistrationBackend(object):
|
||||
"""
|
||||
|
||||
11
forms.py
11
forms.py
@@ -2,6 +2,8 @@ from django import forms
|
||||
from django.contrib.auth.models import User
|
||||
from django.utils.translation import ugettext_lazy as _
|
||||
|
||||
from seaserv import ccnet_rpc
|
||||
|
||||
class AddUserForm(forms.Form):
|
||||
"""
|
||||
Form for adding a user.
|
||||
@@ -12,13 +14,12 @@ class AddUserForm(forms.Form):
|
||||
password2 = forms.CharField(widget=forms.PasswordInput())
|
||||
|
||||
def clean_email(self):
|
||||
try:
|
||||
user = User.objects.get(email__iexact=self.cleaned_data['email'])
|
||||
except User.DoesNotExist:
|
||||
email = self.cleaned_data['email']
|
||||
emailuser = ccnet_rpc.get_emailuser(email)
|
||||
if not emailuser:
|
||||
return self.cleaned_data['email']
|
||||
|
||||
else:
|
||||
raise forms.ValidationError(_("A user with this email already"))
|
||||
|
||||
def clean(self):
|
||||
"""
|
||||
Verifiy that the values entered into the two password fields
|
||||
|
||||
@@ -1,12 +0,0 @@
|
||||
from django.db import models
|
||||
from django.contrib.auth.models import User
|
||||
|
||||
|
||||
#class UserProfile(models.Model):
|
||||
# user = models.ForeignKey(User, unique=True)
|
||||
# ccnet_user_id = models.CharField(max_length=40, blank=True)
|
||||
|
||||
class UserCcnetConf(models.Model):
|
||||
user = models.ForeignKey(User, unique=True)
|
||||
ccnet_user_id = models.CharField(max_length=40, unique=True)
|
||||
ccnet_profile = models.TextField()
|
||||
|
||||
@@ -1,69 +1,9 @@
|
||||
from django.http import HttpResponse, HttpResponseRedirect
|
||||
from django.shortcuts import render_to_response, get_object_or_404
|
||||
from django.template.loader import get_template
|
||||
from django.template import Context, RequestContext
|
||||
from django.contrib.auth.decorators import login_required
|
||||
from django.core.urlresolvers import reverse
|
||||
|
||||
import datetime
|
||||
|
||||
from forms import SetUserProfileForm
|
||||
from models import UserCcnetConf
|
||||
|
||||
from seaserv import ccnet_rpc, translate_time_usec, get_binding_userids
|
||||
|
||||
@login_required
|
||||
def get_ccnet_profile(request):
|
||||
try:
|
||||
ccnet_conf = UserCcnetConf.objects.get(user=request.user)
|
||||
return HttpResponse(ccnet_conf.ccnet_profile)
|
||||
except UserCcnetConf.DoesNotExist:
|
||||
return HttpResponse("")
|
||||
|
||||
|
||||
@login_required
|
||||
def set_ccnet_profile(request):
|
||||
ccnet_id = request.user.user_id
|
||||
|
||||
if request.method == 'POST':
|
||||
ccnet_profile = request.POST.get('ccnet_profile', None)
|
||||
try:
|
||||
ccnet_conf = UserCcnetConf.objects.get(ccnet_user_id=ccnet_id)
|
||||
ccnet_conf.ccnet_profile = ccnet_profile
|
||||
ccnet_conf.save()
|
||||
except UserCcnetConf.DoesNotExist:
|
||||
ccnet_conf = UserCcnetConf(user=request.user,
|
||||
ccnet_user_id=ccnet_id,
|
||||
ccnet_profile=ccnet_profile)
|
||||
ccnet_conf.save()
|
||||
return HttpResponse("ok")
|
||||
else:
|
||||
try:
|
||||
ccnet_conf = UserCcnetConf.objects.get(ccnet_user_id=ccnet_id)
|
||||
ccnet_profile = ccnet_conf.ccnet_profile
|
||||
except UserCcnetConf.DoesNotExist:
|
||||
ccnet_profile = ""
|
||||
|
||||
return render_to_response('profile/set_ccnet_conf.html',
|
||||
{ 'ccnet_profile': ccnet_profile },
|
||||
context_instance=RequestContext(request))
|
||||
|
||||
@login_required
|
||||
def download_profile(request):
|
||||
user_id = request.GET.get('user_id', None)
|
||||
err_msg = ''
|
||||
try:
|
||||
profile = ccnet_rpc.get_user_profile(user_id)
|
||||
except Exception as e:
|
||||
err_msg = str(e)
|
||||
profile = None
|
||||
|
||||
if profile:
|
||||
response = HttpResponse(profile, content_type='application/txt')
|
||||
response['Content-Disposition'] = 'attachment; filename=ccnet.profile'
|
||||
return response
|
||||
else:
|
||||
return HttpResponse("Error: " + err_msg)
|
||||
from seaserv import ccnet_rpc, get_binding_userids
|
||||
|
||||
@login_required
|
||||
def list_userids(request):
|
||||
|
||||
@@ -93,10 +93,10 @@ TEMPLATE_CONTEXT_PROCESSORS = (
|
||||
|
||||
|
||||
INSTALLED_APPS = (
|
||||
'auth',
|
||||
# 'auth',
|
||||
'django.contrib.contenttypes',
|
||||
'django.contrib.sessions',
|
||||
'django.contrib.sites',
|
||||
# 'django.contrib.sites',
|
||||
# 'django.contrib.admin',
|
||||
'registration',
|
||||
# 'avatar',
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
<table class="repo-list">
|
||||
<tr>
|
||||
<th width="12%">名字</th>
|
||||
<th width="33%">邮箱</th>
|
||||
<th width="33%">共享给</th>
|
||||
<th width="40%">描述</th>
|
||||
<th width="15%">操作</th>
|
||||
</tr>
|
||||
@@ -34,7 +34,7 @@
|
||||
<table class="repo-list">
|
||||
<tr>
|
||||
<th width="12%">名字</th>
|
||||
<th width="33%">邮箱</th>
|
||||
<th width="33%">共享来源</th>
|
||||
<th width="40%">描述</th>
|
||||
<th width="15%">操作</th>
|
||||
</tr>
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
from django.db import connection
|
||||
from auth.models import User, Permission
|
||||
|
||||
from seahub.base.accounts import CcnetUser
|
||||
from seaserv import ccnet_rpc, get_ccnetuser
|
||||
@@ -56,63 +55,3 @@ class ModelBackend(object):
|
||||
def get_user(self, username):
|
||||
return get_ccnetuser(username=username)
|
||||
|
||||
|
||||
class RemoteUserBackend(ModelBackend):
|
||||
"""
|
||||
This backend is to be used in conjunction with the ``RemoteUserMiddleware``
|
||||
found in the middleware module of this package, and is used when the server
|
||||
is handling authentication outside of Django.
|
||||
|
||||
By default, the ``authenticate`` method creates ``User`` objects for
|
||||
usernames that don't already exist in the database. Subclasses can disable
|
||||
this behavior by setting the ``create_unknown_user`` attribute to
|
||||
``False``.
|
||||
"""
|
||||
|
||||
# Create a User object if not already in the database?
|
||||
create_unknown_user = True
|
||||
|
||||
def authenticate(self, remote_user):
|
||||
"""
|
||||
The username passed as ``remote_user`` is considered trusted. This
|
||||
method simply returns the ``User`` object with the given username,
|
||||
creating a new ``User`` object if ``create_unknown_user`` is ``True``.
|
||||
|
||||
Returns None if ``create_unknown_user`` is ``False`` and a ``User``
|
||||
object with the given username is not found in the database.
|
||||
"""
|
||||
if not remote_user:
|
||||
return
|
||||
user = None
|
||||
username = self.clean_username(remote_user)
|
||||
|
||||
# Note that this could be accomplished in one try-except clause, but
|
||||
# instead we use get_or_create when creating unknown users since it has
|
||||
# built-in safeguards for multiple threads.
|
||||
if self.create_unknown_user:
|
||||
user, created = User.objects.get_or_create(username=username)
|
||||
if created:
|
||||
user = self.configure_user(user)
|
||||
else:
|
||||
try:
|
||||
user = User.objects.get(username=username)
|
||||
except User.DoesNotExist:
|
||||
pass
|
||||
return user
|
||||
|
||||
def clean_username(self, username):
|
||||
"""
|
||||
Performs any cleaning on the "username" prior to using it to get or
|
||||
create the user object. Returns the cleaned username.
|
||||
|
||||
By default, returns the username unchanged.
|
||||
"""
|
||||
return username
|
||||
|
||||
def configure_user(self, user):
|
||||
"""
|
||||
Configures a user after creation and returns the updated user.
|
||||
|
||||
By default, returns the user unmodified.
|
||||
"""
|
||||
return user
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
from auth.models import User
|
||||
from auth import authenticate
|
||||
from auth.tokens import default_token_generator
|
||||
|
||||
@@ -10,56 +9,6 @@ from django.utils.http import int_to_base36
|
||||
|
||||
from seaserv import get_ccnetuser
|
||||
|
||||
class UserCreationForm(forms.ModelForm):
|
||||
"""
|
||||
A form that creates a user, with no privileges, from the given username and password.
|
||||
"""
|
||||
username = forms.RegexField(label=_("Username"), max_length=30, regex=r'^[\w.@+-]+$',
|
||||
help_text = _("Required. 30 characters or fewer. Letters, digits and @/./+/-/_ only."),
|
||||
error_messages = {'invalid': _("This value may contain only letters, numbers and @/./+/-/_ characters.")})
|
||||
password1 = forms.CharField(label=_("Password"), widget=forms.PasswordInput)
|
||||
password2 = forms.CharField(label=_("Password confirmation"), widget=forms.PasswordInput,
|
||||
help_text = _("Enter the same password as above, for verification."))
|
||||
|
||||
class Meta:
|
||||
model = User
|
||||
fields = ("username",)
|
||||
|
||||
def clean_username(self):
|
||||
username = self.cleaned_data["username"]
|
||||
try:
|
||||
User.objects.get(username=username)
|
||||
except User.DoesNotExist:
|
||||
return username
|
||||
raise forms.ValidationError(_("A user with that username already exists."))
|
||||
|
||||
def clean_password2(self):
|
||||
password1 = self.cleaned_data.get("password1", "")
|
||||
password2 = self.cleaned_data["password2"]
|
||||
if password1 != password2:
|
||||
raise forms.ValidationError(_("The two password fields didn't match."))
|
||||
return password2
|
||||
|
||||
def save(self, commit=True):
|
||||
user = super(UserCreationForm, self).save(commit=False)
|
||||
user.set_password(self.cleaned_data["password1"])
|
||||
if commit:
|
||||
user.save()
|
||||
return user
|
||||
|
||||
class UserChangeForm(forms.ModelForm):
|
||||
username = forms.RegexField(label=_("Username"), max_length=30, regex=r'^[\w.@+-]+$',
|
||||
help_text = _("Required. 30 characters or fewer. Letters, digits and @/./+/-/_ only."),
|
||||
error_messages = {'invalid': _("This value may contain only letters, numbers and @/./+/-/_ characters.")})
|
||||
|
||||
class Meta:
|
||||
model = User
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
super(UserChangeForm, self).__init__(*args, **kwargs)
|
||||
f = self.fields.get('user_permissions', None)
|
||||
if f is not None:
|
||||
f.queryset = f.queryset.select_related('content_type')
|
||||
|
||||
class AuthenticationForm(forms.Form):
|
||||
"""
|
||||
|
||||
@@ -43,358 +43,6 @@ def check_password(raw_password, enc_password):
|
||||
class SiteProfileNotAvailable(Exception):
|
||||
pass
|
||||
|
||||
class PermissionManager(models.Manager):
|
||||
def get_by_natural_key(self, codename, app_label, model):
|
||||
return self.get(
|
||||
codename=codename,
|
||||
content_type=ContentType.objects.get_by_natural_key(app_label, model)
|
||||
)
|
||||
|
||||
class Permission(models.Model):
|
||||
"""The permissions system provides a way to assign permissions to specific users and groups of users.
|
||||
|
||||
The permission system is used by the Django admin site, but may also be useful in your own code. The Django admin site uses permissions as follows:
|
||||
|
||||
- The "add" permission limits the user's ability to view the "add" form and add an object.
|
||||
- The "change" permission limits a user's ability to view the change list, view the "change" form and change an object.
|
||||
- The "delete" permission limits the ability to delete an object.
|
||||
|
||||
Permissions are set globally per type of object, not per specific object instance. It is possible to say "Mary may change news stories," but it's not currently possible to say "Mary may change news stories, but only the ones she created herself" or "Mary may only change news stories that have a certain status or publication date."
|
||||
|
||||
Three basic permissions -- add, change and delete -- are automatically created for each Django model.
|
||||
"""
|
||||
name = models.CharField(_('name'), max_length=50)
|
||||
content_type = models.ForeignKey(ContentType)
|
||||
codename = models.CharField(_('codename'), max_length=100)
|
||||
objects = PermissionManager()
|
||||
|
||||
class Meta:
|
||||
verbose_name = _('permission')
|
||||
verbose_name_plural = _('permissions')
|
||||
unique_together = (('content_type', 'codename'),)
|
||||
ordering = ('content_type__app_label', 'content_type__model', 'codename')
|
||||
|
||||
def __unicode__(self):
|
||||
return u"%s | %s | %s" % (
|
||||
unicode(self.content_type.app_label),
|
||||
unicode(self.content_type),
|
||||
unicode(self.name))
|
||||
|
||||
def natural_key(self):
|
||||
return (self.codename,) + self.content_type.natural_key()
|
||||
natural_key.dependencies = ['contenttypes.contenttype']
|
||||
|
||||
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)
|
||||
|
||||
class Meta:
|
||||
verbose_name = _('group')
|
||||
verbose_name_plural = _('groups')
|
||||
|
||||
def __unicode__(self):
|
||||
return self.name
|
||||
|
||||
class UserManager(models.Manager):
|
||||
def create_user(self, username, email, password=None):
|
||||
"""
|
||||
Creates and saves a User with the given username, e-mail and password.
|
||||
"""
|
||||
|
||||
now = datetime.datetime.now()
|
||||
|
||||
# Normalize the address by lowercasing the domain part of the email
|
||||
# address.
|
||||
try:
|
||||
email_name, domain_part = email.strip().split('@', 1)
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
email = '@'.join([email_name, domain_part.lower()])
|
||||
|
||||
user = self.model(username=username, email=email, is_staff=False,
|
||||
is_active=True, is_superuser=False, last_login=now,
|
||||
date_joined=now)
|
||||
|
||||
if password:
|
||||
user.set_password(password)
|
||||
else:
|
||||
user.set_unusable_password()
|
||||
user.save(using=self._db)
|
||||
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(using=self._db)
|
||||
return u
|
||||
|
||||
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
|
||||
return ''.join([choice(allowed_chars) for i in range(length)])
|
||||
|
||||
|
||||
# A few helper functions for common logic between User and AnonymousUser.
|
||||
def _user_get_all_permissions(user, obj):
|
||||
permissions = set()
|
||||
anon = user.is_anonymous()
|
||||
for backend in auth.get_backends():
|
||||
if not anon or backend.supports_anonymous_user:
|
||||
if hasattr(backend, "get_all_permissions"):
|
||||
if obj is not None:
|
||||
if backend.supports_object_permissions:
|
||||
permissions.update(
|
||||
backend.get_all_permissions(user, obj)
|
||||
)
|
||||
else:
|
||||
permissions.update(backend.get_all_permissions(user))
|
||||
return permissions
|
||||
|
||||
|
||||
def _user_has_perm(user, perm, obj):
|
||||
anon = user.is_anonymous()
|
||||
for backend in auth.get_backends():
|
||||
if not anon or backend.supports_anonymous_user:
|
||||
if hasattr(backend, "has_perm"):
|
||||
if obj is not None:
|
||||
if (backend.supports_object_permissions and
|
||||
backend.has_perm(user, perm, obj)):
|
||||
return True
|
||||
else:
|
||||
if backend.has_perm(user, perm):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def _user_has_module_perms(user, app_label):
|
||||
anon = user.is_anonymous()
|
||||
for backend in auth.get_backends():
|
||||
if not anon or backend.supports_anonymous_user:
|
||||
if hasattr(backend, "has_module_perms"):
|
||||
if backend.has_module_perms(user, app_label):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
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, help_text=_("Required. 30 characters or fewer. Letters, numbers and @/./+/-/_ characters"))
|
||||
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_active = models.BooleanField(_('active'), default=True, help_text=_("Designates whether this user should be treated as active. Unselect this instead of deleting accounts."))
|
||||
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)
|
||||
objects = UserManager()
|
||||
|
||||
class Meta:
|
||||
verbose_name = _('user')
|
||||
verbose_name_plural = _('users')
|
||||
|
||||
def __unicode__(self):
|
||||
return self.username
|
||||
|
||||
def get_absolute_url(self):
|
||||
return "/users/%s/" % urllib.quote(smart_str(self.username))
|
||||
|
||||
def is_anonymous(self):
|
||||
"""
|
||||
Always returns False. This is a way of comparing User objects to
|
||||
anonymous users.
|
||||
"""
|
||||
return False
|
||||
|
||||
def is_authenticated(self):
|
||||
"""
|
||||
Always return True. This is a way to tell if the user has been
|
||||
authenticated in templates.
|
||||
"""
|
||||
return True
|
||||
|
||||
def get_full_name(self):
|
||||
"Returns the first_name plus the last_name, with a space in between."
|
||||
full_name = u'%s %s' % (self.first_name, self.last_name)
|
||||
return full_name.strip()
|
||||
|
||||
def set_password(self, raw_password):
|
||||
import random
|
||||
algo = 'sha1'
|
||||
salt = get_hexdigest(algo, str(random.random()), str(random.random()))[:5]
|
||||
hsh = get_hexdigest(algo, salt, raw_password)
|
||||
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:
|
||||
is_correct = (self.password == get_hexdigest('md5', '', raw_password))
|
||||
if is_correct:
|
||||
# Convert the password to the new, more secure format.
|
||||
self.set_password(raw_password)
|
||||
self.save()
|
||||
return is_correct
|
||||
return check_password(raw_password, self.password)
|
||||
|
||||
def set_unusable_password(self):
|
||||
# Sets a value that will never be a valid hash
|
||||
self.password = UNUSABLE_PASSWORD
|
||||
|
||||
def has_usable_password(self):
|
||||
return self.password != UNUSABLE_PASSWORD
|
||||
|
||||
def get_group_permissions(self, obj=None):
|
||||
"""
|
||||
Returns a list of permission strings that this user has through
|
||||
his/her groups. This method queries all available auth backends.
|
||||
If an object is passed in, only permissions matching this object
|
||||
are returned.
|
||||
"""
|
||||
permissions = set()
|
||||
for backend in auth.get_backends():
|
||||
if hasattr(backend, "get_group_permissions"):
|
||||
if obj is not None:
|
||||
if backend.supports_object_permissions:
|
||||
permissions.update(
|
||||
backend.get_group_permissions(self, obj)
|
||||
)
|
||||
else:
|
||||
permissions.update(backend.get_group_permissions(self))
|
||||
return permissions
|
||||
|
||||
def get_all_permissions(self, obj=None):
|
||||
return _user_get_all_permissions(self, obj)
|
||||
|
||||
def has_perm(self, perm, obj=None):
|
||||
"""
|
||||
Returns True if the user has the specified permission. This method
|
||||
queries all available auth backends, but returns immediately if any
|
||||
backend returns True. Thus, a user who has permission from a single
|
||||
auth backend is assumed to have permission in general. If an object
|
||||
is provided, permissions for this specific object are checked.
|
||||
"""
|
||||
# Inactive users have no permissions.
|
||||
if not self.is_active:
|
||||
return False
|
||||
|
||||
# Superusers have all permissions.
|
||||
if self.is_superuser:
|
||||
return True
|
||||
|
||||
# Otherwise we need to check the backends.
|
||||
return _user_has_perm(self, perm, obj)
|
||||
|
||||
def has_perms(self, perm_list, obj=None):
|
||||
"""
|
||||
Returns True if the user has each of the specified permissions.
|
||||
If object is passed, it checks if the user has all required perms
|
||||
for this object.
|
||||
"""
|
||||
for perm in perm_list:
|
||||
if not self.has_perm(perm, obj):
|
||||
return False
|
||||
return True
|
||||
|
||||
def has_module_perms(self, app_label):
|
||||
"""
|
||||
Returns True if the user has any permissions in the given app
|
||||
label. Uses pretty much the same logic as has_perm, above.
|
||||
"""
|
||||
if not self.is_active:
|
||||
return False
|
||||
|
||||
if self.is_superuser:
|
||||
return True
|
||||
|
||||
return _user_has_module_perms(self, app_label)
|
||||
|
||||
def get_and_delete_messages(self):
|
||||
messages = []
|
||||
for m in self.message_set.all():
|
||||
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 import settings
|
||||
if not getattr(settings, 'AUTH_PROFILE_MODULE', False):
|
||||
raise SiteProfileNotAvailable('You need to set AUTH_PROFILE_MO'
|
||||
'DULE in your project settings')
|
||||
try:
|
||||
app_label, model_name = settings.AUTH_PROFILE_MODULE.split('.')
|
||||
except ValueError:
|
||||
raise SiteProfileNotAvailable('app_label and model_name should'
|
||||
' be separated by a dot in the AUTH_PROFILE_MODULE set'
|
||||
'ting')
|
||||
|
||||
try:
|
||||
model = models.get_model(app_label, model_name)
|
||||
if model is None:
|
||||
raise SiteProfileNotAvailable('Unable to load the profile '
|
||||
'model, check AUTH_PROFILE_MODULE in your project sett'
|
||||
'ings')
|
||||
self._profile_cache = model._default_manager.using(self._state.db).get(user__id__exact=self.id)
|
||||
self._profile_cache.user = self
|
||||
except (ImportError, ImproperlyConfigured):
|
||||
raise SiteProfileNotAvailable
|
||||
return self._profile_cache
|
||||
|
||||
def _get_message_set(self):
|
||||
import warnings
|
||||
warnings.warn('The user messaging API is deprecated. Please update'
|
||||
' your code to use the new messages framework.',
|
||||
category=PendingDeprecationWarning)
|
||||
return self._message_set
|
||||
message_set = property(_get_message_set)
|
||||
|
||||
class Message(models.Model):
|
||||
"""
|
||||
The message system is a lightweight way to queue messages for given
|
||||
users. A message is associated with a User instance (so it is only
|
||||
applicable for registered users). There's no concept of expiration or
|
||||
timestamps. Messages are created by the Django admin after successful
|
||||
actions. For example, "The poll Foo was created successfully." is a
|
||||
message.
|
||||
"""
|
||||
user = models.ForeignKey(User, related_name='_message_set')
|
||||
message = models.TextField(_('message'))
|
||||
|
||||
def __unicode__(self):
|
||||
return self.message
|
||||
|
||||
class AnonymousUser(object):
|
||||
id = None
|
||||
|
||||
@@ -17,7 +17,6 @@ from auth.decorators import login_required
|
||||
from auth.forms import AuthenticationForm
|
||||
from auth.forms import PasswordResetForm, SetPasswordForm, PasswordChangeForm
|
||||
from auth.tokens import default_token_generator
|
||||
from auth.models import User
|
||||
|
||||
from seaserv import get_ccnetuser
|
||||
|
||||
|
||||
@@ -3,7 +3,6 @@ import random
|
||||
import re
|
||||
|
||||
from django.conf import settings
|
||||
from auth.models import User
|
||||
|
||||
from django.db import models
|
||||
from django.db import transaction
|
||||
|
||||
1
views.py
1
views.py
@@ -4,7 +4,6 @@ from django.core.urlresolvers import reverse
|
||||
from django.template import RequestContext
|
||||
from auth.decorators import login_required
|
||||
from django.db import IntegrityError
|
||||
from auth.models import User
|
||||
from django.views.decorators.csrf import csrf_protect
|
||||
from auth.forms import AuthenticationForm, PasswordResetForm, SetPasswordForm, PasswordChangeForm
|
||||
from auth.tokens import default_token_generator
|
||||
|
||||
Reference in New Issue
Block a user