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