class AnonymousUser(object): id = None pk = None username = '' is_staff = False is_active = False is_superuser = False _groups = EmptyManager(Group) _user_permissions = EmptyManager(Permission) def __init__(self): pass def __str__(self): return 'AnonymousUser' def __eq__(self, other): return isinstance(other, self.__class__) def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return 1 # instances always return the same hash value def save(self): raise NotImplementedError( "Django doesn't provide a DB representation for AnonymousUser.") def delete(self): raise NotImplementedError( "Django doesn't provide a DB representation for AnonymousUser.") def set_password(self, raw_password): raise NotImplementedError( "Django doesn't provide a DB representation for AnonymousUser.") def check_password(self, raw_password): raise NotImplementedError( "Django doesn't provide a DB representation for AnonymousUser.") @property def groups(self): return self._groups @property def user_permissions(self): return self._user_permissions def get_group_permissions(self, obj=None): return set() def get_all_permissions(self, obj=None): return _user_get_all_permissions(self, obj=obj) def has_perm(self, perm, obj=None): return _user_has_perm(self, perm, obj=obj) def has_perms(self, perm_list, obj=None): for perm in perm_list: if not self.has_perm(perm, obj): return False return True def has_module_perms(self, module): return _user_has_module_perms(self, module) @property def is_anonymous(self): return CallableTrue @property def is_authenticated(self): return CallableFalse def get_username(self): return self.username
class AnonymousUser(object): id = None username = '' is_staff = False is_active = False is_superuser = False _groups = EmptyManager() _user_permissions = EmptyManager() def __init__(self): pass def __unicode__(self): return 'AnonymousUser' def __str__(self): return unicode(self).encode('utf-8') def __eq__(self, other): return isinstance(other, self.__class__) def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return 1 # instances always return the same hash value def save(self): raise NotImplementedError def delete(self): raise NotImplementedError def set_password(self, raw_password): raise NotImplementedError def check_password(self, raw_password): raise NotImplementedError def _get_groups(self): return self._groups groups = property(_get_groups) def _get_user_permissions(self): return self._user_permissions user_permissions = property(_get_user_permissions) def get_group_permissions(self, obj=None): return set() def get_all_permissions(self, obj=None): return _user_get_all_permissions(self, obj=obj) def has_perm(self, perm, obj=None): return _user_has_perm(self, perm, obj=obj) def has_perms(self, perm_list, obj=None): for perm in perm_list: if not self.has_perm(perm, obj): return False return True def has_module_perms(self, module): return _user_has_module_perms(self, module) def get_and_delete_messages(self): return [] def is_anonymous(self): return True def is_authenticated(self): return False
class AnonymousUser: id = None pk = None username = '' is_staff = False is_active = False is_superuser = False _groups = EmptyManager(Group) _user_permissions = EmptyManager(Permission) def __str__(self): return 'AnonymousUser' def __eq__(self, other): return isinstance(other, self.__class__) def __hash__(self): return 1 # instances always return the same hash value def __int__(self): raise TypeError( 'Cannot cast AnonymousUser to int. Are you trying to use it in place of User?' ) def save(self): raise NotImplementedError( "Django doesn't provide a DB representation for AnonymousUser.") def delete(self): raise NotImplementedError( "Django doesn't provide a DB representation for AnonymousUser.") def set_password(self, raw_password): raise NotImplementedError( "Django doesn't provide a DB representation for AnonymousUser.") def check_password(self, raw_password): raise NotImplementedError( "Django doesn't provide a DB representation for AnonymousUser.") @property def groups(self): return self._groups @property def user_permissions(self): return self._user_permissions def get_user_permissions(self, obj=None): return _user_get_permissions(self, obj, 'user') def get_group_permissions(self, obj=None): return set() def get_all_permissions(self, obj=None): return _user_get_permissions(self, obj, 'all') def has_perm(self, perm, obj=None): return _user_has_perm(self, perm, obj=obj) def has_perms(self, perm_list, obj=None): return all(self.has_perm(perm, obj) for perm in perm_list) def has_module_perms(self, module): return _user_has_module_perms(self, module) @property def is_anonymous(self): return True @property def is_authenticated(self): return False def get_username(self): return self.username
class User(BaseModel): """A model with the same attributes and methods as a Django user model. The model has two additions. The first addition is a 'user' attribute which references a App Engine user. The second is the 'get_djangouser_for_user' classmethod that should be used to retrieve a DjangoUser instance from a App Engine user object. """ user = db.UserProperty(required=True) username = db.StringProperty(required=True) first_name = db.StringProperty() last_name = db.StringProperty() email = db.EmailProperty() password = db.StringProperty() is_staff = db.BooleanProperty(default=False, required=True) is_active = db.BooleanProperty(default=True, required=True) is_superuser = db.BooleanProperty(default=False, required=True) last_login = db.DateTimeProperty(auto_now_add=True, required=True) date_joined = db.DateTimeProperty(auto_now_add=True, required=True) groups = EmptyManager() user_permissions = EmptyManager() def __unicode__(self): return self.username def __str__(self): return unicode(self).encode('utf-8') @classmethod def get_djangouser_for_user(cls, user): django_user = cls.get_by_key_name(user.user_id()) if django_user: return django_user # Check to make sure there's no legacy User object before creating a new # one (new style User objects use a key_name based on the user_id). django_user = cls.all().filter('user ='******'%s %s' % (self.first_name, self.last_name) return full_name.strip() def email_user(self, subject, message, from_email): """Sends an email to this user. According to the App Engine email API the from_email must be the email address of a registered administrator for the application. """ 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. When using the App Engine authentication framework, users are created automatically. """ from django.contrib.auth.models import SiteProfileNotAvailable if not hasattr(self, '_profile_cache'): from django.conf import settings if not hasattr(settings, "AUTH_PROFILE_MODULE"): raise SiteProfileNotAvailable try: app_label, model_name = settings.AUTH_PROFILE_MODULE.split('.') model = models.get_model(app_label, model_name) self._profile_cache = model.all().filter("user =", self).get() if not self._profile_cache: raise model.DoesNotExist except (ImportError, ImproperlyConfigured): raise SiteProfileNotAvailable return self._profile_cache
class Group(BaseModel): """Group model not fully implemented yet.""" # TODO: Implement this model, requires contenttypes name = db.StringProperty() permissions = EmptyManager()
class TokenUser: """ A dummy user class modeled after django.contrib.auth.models.AnonymousUser. Used in conjunction with the `JWTTokenUserAuthentication` backend to implement single sign-on functionality across services which share the same secret key. `JWTTokenUserAuthentication` will return an instance of this class instead of a `User` model instance. Instances of this class act as stateless user objects which are backed by validated tokens. """ # User is always active since Simple JWT will never issue a token for an # inactive user is_active = True _groups = EmptyManager(auth_models.Group) _user_permissions = EmptyManager(auth_models.Permission) def __init__(self, token): self.token = token def __str__(self): return 'TokenUser {}'.format(self.id) @cached_property def id(self): return self.token[api_settings.USER_ID_CLAIM] @cached_property def pk(self): return self.id @cached_property def username(self): return self.token.get('username', '') @cached_property def is_staff(self): return self.token.get('is_staff', False) @cached_property def is_superuser(self): return self.token.get('is_superuser', False) def __eq__(self, other): return self.id == other.id def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return hash(self.id) def save(self): raise NotImplementedError('Token users have no DB representation') def delete(self): raise NotImplementedError('Token users have no DB representation') def set_password(self, raw_password): raise NotImplementedError('Token users have no DB representation') def check_password(self, raw_password): raise NotImplementedError('Token users have no DB representation') @property def groups(self): return self._groups @property def user_permissions(self): return self._user_permissions def get_group_permissions(self, obj=None): return set() def get_all_permissions(self, obj=None): return set() def has_perm(self, perm, obj=None): return False def has_perms(self, perm_list, obj=None): return False def has_module_perms(self, module): return False @property def is_anonymous(self): return CallableFalse @property def is_authenticated(self): return CallableTrue def get_username(self): return self.username
def __init__(self, token): self.token = token from django.contrib.auth import models as auth_models self._groups = EmptyManager(auth_models.Group) self._user_permissions = EmptyManager(auth_models.Permission)
class BettyCropperUser(object): id = None pk = None username = '' is_staff = False is_active = False is_superuser = False if django.VERSION[1] < 6: _groups = EmptyManager() else: _groups = EmptyManager(Group) def __init__(self, permissions): self._permissions = permissions def __str__(self): return 'BettyCropperUser' def __eq__(self, other): return isinstance(other, self.__class__) def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return 1 # instances always return the same hash value def save(self): raise NotImplementedError( "Django doesn't provide a DB representation for BettyCropperUser.") def delete(self): raise NotImplementedError( "Django doesn't provide a DB representation for BettyCropperUser.") def set_password(self, raw_password): raise NotImplementedError( "Django doesn't provide a DB representation for BettyCropperUser.") def check_password(self, raw_password): raise NotImplementedError( "Django doesn't provide a DB representation for BettyCropperUser.") def _get_groups(self): return self._groups groups = property(_get_groups) def _get_user_permissions(self): return self._permissions user_permissions = property(_get_user_permissions) def get_group_permissions(self, obj=None): return set() def get_all_permissions(self, obj=None): return self._permissions def has_perm(self, perm, obj=None): return perm in self._permissions def has_perms(self, perm_list, obj=None): for perm in perm_list: if not self.has_perm(perm, obj): return False return True def has_module_perms(self, module): return module == "server" and self._permissions def is_anonymous(self): return False def is_authenticated(self): return True