class UserManager(BaseUserManager.from_queryset(UserQuerySet)):
def create_user(self, serial, password=None, **extra):
if not serial:
raise ValueError('Users must have a serial')
user = self.model(serial=serial, **extra)
user.set_password(password)
user.save(using=self._db)
return user
def create_superuser(self, serial, password, **extra):
user = self.create_user(serial=serial, password=password, **extra)
user.is_staff = True
user.save(using=self._db)
return user
def get_queryset(self):
return super().get_queryset().exclude(serial='__system__')
def get_queryset_unfiltered(self):
# Use the parent's queryset, as it is not filtered
return super().get_queryset()
def get_system_user(self):
return self.get_queryset_unfiltered().get(serial='__system__')
class UserManager(BaseUserManager.from_queryset(UserQueryset)):
"""Custom manager for User.
"""
def _create_user(self, email, password, **extra_fields):
"""Create and save an EmailUser with the given email and password.
:param str email: user email
:param str password: user password
:param bool is_staff: whether user staff or not
:param bool is_superuser: whether user admin or not
:return custom_user.models.EmailUser user: user
:raise ValueError: email is not set
"""
now = timezone.now()
if not email:
raise ValueError('The given email must be set')
email = self.normalize_email(email)
last_login = extra_fields.pop('last_login', now)
date_joined = extra_fields.pop('date_joined', now)
user = self.model(
email=email, last_login=last_login, date_joined=date_joined,
**extra_fields
)
user.set_password(password)
user.save(using=self._db)
return user
def create_user(self, email, password=None, **extra_fields):
"""Create and save an EmailUser with the given email and password.
:param str email: user email
:param str password: user password
:return custom_user.models.EmailUser user: regular user
"""
return self._create_user(email, password, **extra_fields)
def create_superuser(self, email, password, **extra_fields):
"""Create and save an EmailUser with the given email and password.
:param str email: user email
:param str password: user password
:return custom_user.models.EmailUser user: admin user
"""
return self._create_user(
email, password, verified=True,
is_staff=True, is_superuser=True,
**extra_fields
)
def get_with_verification_key(self, verification_key):
"""Get a user from verification key.
"""
try:
username = signing.loads(
verification_key,
salt=settings.SECRET_KEY,
)
except signing.BadSignature:
raise self.model.DoesNotExist
return self.get(**{self.model.USERNAME_FIELD: username})
class UserManager(BaseUserManager.from_queryset(UsersQuerySet)):
use_for_related_fields = True
def _create_user(self, username: str, email, password, is_staff,
is_superuser, **extra_fields):
"""
Creates and saves a User with the given username, email and password.
"""
now = timezone.now()
email = self.normalize_email(email)
user = self.model(username=username,
email=email,
is_staff=is_staff,
is_active=True,
is_superuser=is_superuser,
last_login=now,
date_joined=now,
**extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
def create_user(self,
username: str,
email=None,
password=None,
**extra_fields):
return self._create_user(username, email, password, False, False,
**extra_fields)
def create_superuser(self, username: str, email, password, **extra_fields):
return self._create_user(username, email, password, True, True,
**extra_fields)
class UserManager(BaseUserManager.from_queryset(UserQuerySet)):
def create_user(self, username, email, password=None, **kwargs):
user = self.model(
username=username, email=self.normalize_email(email), **kwargs
)
user.set_password(password)
user.save(using=self._db)
return user
def create_superuser(self, username, email, password, **kwargs):
return self.create_user(
username, email, password, is_staff=True, is_superuser=True, **kwargs,
)
class UserManager(BaseUserManager.from_queryset(UserQuerySet)): # type: ignore # noqa: Z454
"""Переопределение менеджера для модели User."""
def get_by_natural_key(self, username):
"""Для получения пользователя по полю USERNAME_FIELD модели."""
# Запрос не должен учитывать регистр
case_insensitive_username_field = f'{self.model.USERNAME_FIELD}__iexact'
user = self.filter(
**{case_insensitive_username_field: username},
).first()
if not user:
raise User.DoesNotExist
return user
def create_user(self, email, password=None, **kwargs):
"""Создание пользователя."""
if not email:
raise ValueError('Users must have an email address')
# email сохраняем в lower case
user = self.model(
email=self.normalize_email(email.lower()),
**kwargs,
)
user.set_password(password)
user.save(using=self._db)
return user
def create_superuser(self, email, password, **kwargs):
"""Создание пользователя с правами администратора."""
user = self.create_user(
email,
password=password,
**kwargs,
)
user.is_superuser = True
user.is_staff = True
user.save(using=self._db)
return user
def delete(self):
"""Override method."""
logger.warning("You can't remove all users using UserManager")
def get_query_set(self):
"""Возвращаем наш queryset."""
return UserQuerySet(self.model, using=self._db)
class UserManager(BaseUserManager.from_queryset(UserQuerySet)):
def create_user(self, serial, password=None, **extra):
if not serial:
raise ValueError('Users must have a serial')
user = self.model(serial=serial, **extra)
user.set_password(password)
user.save(using=self._db)
return user
def create_superuser(self, serial, password, **extra):
user = self.create_user(serial=serial, password=password, **extra)
user.is_staff = True
user.save(using=self._db)
return user
class LocalUser(AbstractUser):
objects = BaseUserManager.from_queryset(UserQuerySet)()
email = models.EmailField(
_('email address'),
unique=True,
help_text=_(
'Required, a confirmation message will be sent to this address.'))
jid = models.CharField(
_('JID'),
max_length=128,
unique=True,
help_text=_(
'Required, a confirmation message will be sent to this address.'))
email_confirmed = models.BooleanField(default=False)
jid_confirmed = models.BooleanField(default=False)
class UserManager(BaseUserManager.from_queryset(UserQuerySet)):
use_in_migrations = True
def _create_user(self, email, password, **extra_fields):
"""
Creates and saves a User with the given username, email and password.
"""
if not email:
raise ValueError('The given email must be set')
email = self.normalize_email(email)
user = self.model(email=email, **extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
def create_user(self, email, password=None, **extra_fields):
extra_fields.setdefault('is_staff', False)
extra_fields.setdefault('is_superuser', False)
return self._create_user(email, password, **extra_fields)
def create_superuser(self, email, password, **extra_fields):
extra_fields.setdefault('is_staff', True)
extra_fields.setdefault('is_superuser', True)
if extra_fields.get('is_staff') is not True:
raise ValueError('Superuser must have is_staff=True.')
if extra_fields.get('is_superuser') is not True:
raise ValueError('Superuser must have is_superuser=True.')
return self._create_user(email, password, **extra_fields)
def get_or_create_and_notify(self, defaults=dict(), site=None, **kwargs):
# Set a temp password so users can access the password reset function if needed.
temp_pass = BaseUserManager().make_random_password(length=32)
temp_pass_hash = make_password(temp_pass)
defaults.update(password=temp_pass_hash)
user, created = self.get_or_create(defaults=defaults, **kwargs)
if created:
send_activation_email(user, site)
applicant_group = Group.objects.get(name=APPLICANT_GROUP_NAME)
user.groups.add(applicant_group)
user.save()
return user, created
class UserManager(BaseUserManager.from_queryset(UserQuerySet)):
def create_user(self,
username: str,
email: str,
password: Optional[str] = None,
**kwargs) -> settings.AUTH_USER_MODEL:
user = self.model(username=username,
email=self.normalize_email(email),
**kwargs)
user.set_password(password)
user.save(using=self._db)
return user
def create_superuser(self, username: str, email: str, password: str,
**kwargs) -> settings.AUTH_USER_MODEL:
return self.create_user(
username,
email,
password,
is_staff=True,
is_superuser=True,
**kwargs,
)
class UserManager(BaseUserManager.from_queryset(UserQuerySet)):
def _create_user(self, username, password, **extra_fields):
username = self.model.normalize_username(username)
user = self.model(username=username, **extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
def create_user(self, username, password=None, **extra_fields):
extra_fields.setdefault('is_staff', False)
extra_fields.setdefault('is_superuser', False)
return self._create_user(username, password, **extra_fields)
def create_superuser(self, username, password, **extra_fields):
extra_fields.setdefault('is_staff', True)
extra_fields.setdefault('is_superuser', True)
if extra_fields.get('is_staff') is not True:
raise ValueError('Superuser must have is_staff=True.')
if extra_fields.get('is_superuser') is not True:
raise ValueError('Superuser must have is_superuser=True.')
return self._create_user(username, password, **extra_fields)
from ore.core.models import Namespace, Organization
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, AnonymousUser, BaseUserManager
from django.contrib.contenttypes.models import ContentType
from django.core.mail import send_mail
from django.db import models
from django.db.models import Q
from django.utils import timezone
from django.utils.translation import ugettext_lazy as _t
import hashlib
from ore.core.util import UserFilteringQuerySet
from reversion import revisions as reversion
OreUserManagerBase = BaseUserManager.from_queryset(UserFilteringQuerySet)
class OreUserManager(OreUserManagerBase):
def create_user(self, name, password=None, email=None, **extra_fields):
now = timezone.now()
email = self.normalize_email(email)
user = self.model(
name=name,
**extra_fields
)
user.set_password(password)
# we'll create a superuser if this is the only user
if not self.exists():
user.is_staff = True
user.is_superuser = True
