def test_create_superuser_sets_is_staff_and_is_superuser_to_true_if_not_defined(self):
manager = UserManager()
email = '*****@*****.**'
password = '******'
manager.create_superuser(email, password)
manager._create_user.assert_called_with(email, password, is_staff=True, is_superuser=True)
def test_create_user_raises_value_error_if_normalized_email_is_empty_string(self):
manager = UserManager()
manager.normalize_email.return_value = ''
email = '*****@*****.**'
password = '******'
with pytest.raises(ValueError):
manager._create_user(email, password)
def test_create_superuser_raises_an_error_if_is_staff_or_is_superuser_is_not_true(self, is_staff, is_superuser):
manager = UserManager()
email = '*****@*****.**'
password = '******'
kwargs = {
'is_staff': is_staff,
'is_superuser': is_superuser
}
with pytest.raises(ValueError):
manager.create_superuser(email, password, **kwargs)
def test_create_user_uses_user_values_or_sets_defaults_for_is_staff_and_is_superuser_if_not_defined(self, is_staff, is_superuser, expected_is_staff, expected_is_superuser):
manager = UserManager()
email = '*****@*****.**'
password = '******'
kwargs = {}
if is_staff is not None:
kwargs['is_staff'] = is_staff
if is_superuser is not None:
kwargs['is_superuser'] = is_superuser
manager.create_user(email, password, **kwargs)
manager._create_user.assert_called_with(
email, password, is_staff=expected_is_staff, is_superuser=expected_is_superuser
)
class User(AbstractBaseUser, BaseIsDeletedModel, PermissionsMixin):
user_id = models.CharField('유저아이디', max_length=15, unique=True, )
email = models.EmailField('유저이메일', unique=True, )
nickname = models.CharField('별명', max_length=15, )
description = models.TextField('자기소개', blank=True, null=True)
profile_image = models.ImageField('프로필 이미지', upload_to='profile/', blank=True, null=True)
relation_users = models.ManyToManyField(
'self',
symmetrical=False,
through='UserRelation',
)
objects = UserManager()
USERNAME_FIELD = 'user_id'
REQUIRED_FIELDS = ['email', ]
class Meta:
verbose_name = ('유저', )
verbose_name_plural = ('유저', )
def delete(self, using=None, keep_parents=False):
super().delete()
Token.objects.filter(user=self).delete()
class CustomUser(AbstractBaseUser, PermissionsMixin):
username = models.CharField(_('Username'), max_length=10, unique=True)
first_and_last_name = models.CharField(_('First and last name'), max_length=50, blank=True)
email = models.EmailField(_('Email'), unique=True, blank=True, null=True)
phone = PhoneNumberField(_('Phone number'), unique=True, blank=True, null=True)
date_joined = models.DateTimeField(_('Date joined'), default=timezone.now)
is_active = models.BooleanField(_('Active status'), default=True)
is_staff = models.BooleanField(
_('Staff status'),
default=False,
help_text=_('Designates whether the user can log into this admin site.'),
)
avatar = models.ImageField(_('Avatar'), upload_to='avatars/', null=True, blank=True)
email_confirmed = models.BooleanField(_('Email confirmed'), default=False)
phone_confirmed = models.BooleanField(_('Phone confirmed'), default=False)
unconfirmed_email = models.EmailField(_('Unconfirmed email'), null=True, blank=True)
unconfirmed_phone = PhoneNumberField(_('Unconfirmed phone'), null=True, blank=True)
objects = UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = []
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def email_user(self, subject, message, from_email=None, **kwargs):
"""Send an email to this user."""
send_mail(subject, message, from_email, [self.unconfirmed_email], **kwargs)
class User(AbstractUser):
REQUIRED_FIELDS = []
objects = UserManager()
# save user vectors (numpy array in binary)
vector = models.BinaryField(blank=True, null=True)
def save(self, *args, **kwargs):
return super().save(*args, **kwargs)
def init_vector(self):
# add default vector
np_default = np.zeros(shape=(100,), dtype=np.float32)
np_bytes = pickle.dumps(np_default)
np_base64 = base64.b64encode(np_bytes)
self.vector = np_base64
self.save()
# when goal is added, the user vector is updated
# currently, the user vector is (total goal vector) / n
def update_vector(self, np_vector, count):
# binary -> np of the self.vector
if self.vector is None:
self.init_vector()
np_bytes = base64.b64decode(self.vector)
np_array = pickle.loads(np_bytes)
np_array_update = (np_array*(count-1) + np_vector)/count
# encode to binary again to save
# print("USER_VECTOR_UPDATE")
# print(np_array_update)
np_bytes_update = pickle.dumps(np_array_update)
np_base64_update = base64.b64encode(np_bytes_update)
self.vector = np_base64_update
self.save()
class User(AbstractUser):
"""Stores a single user entry."""
avatar = models.ImageField(
'Avatar',
upload_to='avatars/',
default='avatars/default.png',
)
email = models.EmailField('Email', unique=True)
riot_id = models.CharField('Riot ID', max_length=255, blank=True)
riot_tag = models.CharField('Riot Tag', max_length=255, blank=True)
timezone = models.CharField(
'Timezone',
max_length=64,
choices=TIMEZONES,
default='UTC',
)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = []
objects = UserManager()
def __str__(self):
return f'{self.email}'
@property
def full_riot_id(self):
"""Returns the full Riot ID of the user: riot_id#riot_tag."""
return f'{self.riot_id} #{self.riot_tag}'
class User(AbstractBaseUser):
full_name = models.CharField(max_length=255)
email = models.EmailField(max_length=255, unique=True)
password = models.CharField(max_length=255)
is_active = models.BooleanField(default=True)
is_staff = models.BooleanField(default=False)
is_admin = models.BooleanField(default=False)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['full_name', 'password']
objects = UserManager()
def __str__(self):
return self.email
def get_full_name(self):
return self.full_name
def get_short_name(self):
return self.email
def has_perm(self, perm, obj=None):
return self.is_admin
def has_module_perms(self, app_label):
return self.is_admin
class User(AbstractBaseUser, PermissionsMixin, IndexedTimeStampedModel):
email = models.EmailField(max_length=255, unique=True)
name = models.CharField(max_length=255, blank=True)
username = models.CharField(max_length=255, unique=True)
is_staff = models.BooleanField(
default=False,
help_text=_('Designates whether the user can log into this admin '
'site.'))
is_active = models.BooleanField(
default=True,
help_text=_('Designates whether this user should be treated as '
'active. Unselect this instead of deleting accounts.'))
objects = UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
def get_email(self):
return self.email
def get_username(self):
return self.username
def __str__(self):
return self.email
class User(AbstractBaseUser, PermissionsMixin):
email = models.EmailField(_('email address'), unique=True)
first_name = models.CharField(_('first name'), max_length=30, blank=True)
last_name = models.CharField(_('last name'), max_length=30, blank=True)
date_joined = models.DateTimeField(_('date joined'), auto_now_add=True)
is_active = models.BooleanField(_('active'), default=True)
is_staff = models.BooleanField(default=True)
objects = UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = []
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def get_full_name(self):
full_name = '%s %s' % (self.first_name, self.last_name)
return full_name.strip()
def get_short_name(self):
return self.first_name
def __str__(self):
return "{} - {}".format(self.pk, self.get_full_name())
class User(RowInformation, AbstractUser):
first_name = models.CharField(max_length=140, null=False, blank=False)
last_name = models.CharField(max_length=140, null=False, blank=False)
username = models.CharField(max_length=140,
null=False,
blank=False,
unique=True,
validators=[UnicodeUsernameValidator])
email = models.CharField(max_length=140,
null=False,
blank=False,
unique=True)
profile_pic = models.URLField(null=True, blank=True)
following = models.ManyToManyField(to='User',
related_name='followed_by',
null=True,
blank=True)
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['first_name', 'last_name', 'email', 'password']
objects = UserManager()
def save(self, *args, **kwargs):
super(User, self).save(*args, **kwargs)
def __str__(self):
return "{0} {1}".format(self.first_name, self.last_name)
class User(AbstractBaseUser, PermissionsMixin, DateModel):
# Base
email = models.EmailField(verbose_name=_('Email'),
max_length=255,
unique=True)
first_name = models.CharField(verbose_name=_('First Name'), max_length=50)
last_name = models.CharField(verbose_name=_('Last Name'), max_length=50)
password = models.CharField(verbose_name=_('Password'), max_length=255)
# Permissions
is_active = models.BooleanField(verbose_name=_('Active'), default=True)
is_staff = models.BooleanField(verbose_name=_('Staff'), default=False)
is_verified = models.BooleanField(verbose_name=_('Verified'),
default=False)
objects = UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['first_name', 'last_name']
class Meta:
verbose_name = _('User')
verbose_name_plural = _('Users')
def __str__(self):
return self.get_full_name()
def get_full_name(self):
return '{first_name} {last_name}'.format(first_name=self.first_name,
last_name=self.last_name)
def get_short_name(self):
return '{first_name}'.format(first_name=self.first_name)
class User(PermissionsMixin, AbstractBaseUser, Timestampable):
USERNAME_FIELD = 'username'
EMAIL_FIELD = 'email'
# For the createsuperuser command only.
REQUIRED_FIELDS = ['email']
objects = UserManager()
uuid = models.UUIDField(default=uuid.uuid4, unique=True)
username = models.CharField(_('username'), max_length=150, unique=True)
first_name = models.CharField(_('first name'), max_length=255)
last_name = models.CharField(_('last name'), max_length=255)
# This field is for better searching.
full_name = models.CharField(_('full name'), max_length=255, blank=True)
email = models.EmailField(_('email address'), unique=True)
date_of_birth = models.DateField(_('date of birth'), blank=True, null=True)
date_joined = models.DateTimeField(_('date joined'), blank=True, null=True)
# SETTINGS
is_staff = models.BooleanField(_('is staff'), default=False)
# deleted AND invited users will have is_active false
is_active = models.BooleanField(_('is active'), default=False)
STATUS_INVITED = 'invited'
STATUS_ACCEPTED = 'accepted'
# invalidate complete user registration emails if activation_status is accepted
ACTIVATION_STATUS = Choices(STATUS_INVITED, STATUS_ACCEPTED)
activation_status = StatusField(verbose_name="Activation status",
choices_name='ACTIVATION_STATUS')
class Meta:
verbose_name = 'User'
verbose_name_plural = 'Users'
def __str__(self):
return f"{self.full_name} – {self.username}"
# pylint: disable=arguments-differ
def save(self, *args, **kwargs):
self.full_name = self.get_full_name()
super().save(*args, **kwargs)
def get_full_name(self):
return '{} {}'.format(
self.first_name,
self.last_name) if self.first_name and self.last_name else ''
class User(PermissionsMixin, AbstractBaseUser, Timestampable):
USERNAME_FIELD = 'email'
# For the createsuperuser command only.
objects = UserManager()
uuid = models.UUIDField(
default=uuid.uuid4,
unique=True
)
first_name = models.CharField(
_('first name'),
max_length=255)
last_name = models.CharField(
_('last name'),
max_length=255)
email = models.EmailField(
_('email address'), unique=True, null=False, blank=False)
# ['DEVELOPER', 'QA', 'CEO', 'DESIGNER', 'PROJECT MANAGER', 'HR']
designation = models.CharField(null=True, blank=True,
max_length=255)
technologies = models.CharField(null=True, blank=True,
max_length=255)
# ['EMPLOYEE', 'MANAGER', 'ADMIN']
type = models.CharField(null=True, blank=True,
max_length=255)
# SETTINGS
is_staff = models.BooleanField(
_('is staff'),
default=False
)
is_active = models.BooleanField(
_('is active'),
default=False
)
class Meta:
verbose_name = 'User'
verbose_name_plural = 'Users'
def __str__(self):
return f"{self.first_name} – {self.email}"
# pylint: disable=arguments-differ
def save(self, *args, **kwargs):
# print("hello")
super().save(*args, **kwargs)
def get_full_name(self):
return f"{self.first_name} {self.last_name}"
class User(AbstractUser):
username = None
email = models.EmailField(unique=True)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = []
objects = UserManager()
def __str__(self):
return f'{self.first_name} {self.last_name} - {self.email}'
class User(AbstractUser):
username = None
email = models.EmailField(_('email address'), unique=True)
date_joined = models.DateTimeField(default=timezone.now)
USERNAME_FIELD = "email"
REQUIRED_FIELDS = []
objects = UserManager()
def __str__(self):
return self.email
class User(AbstractBaseUser, PermissionsMixin, ExportModelOperationsMixin("user")):
username = models.CharField(max_length=50, unique=True)
email = models.EmailField(unique=True)
USERNAME_FIELD = 'username'
EMAIL_FIELD = 'email'
REQUIRED_FIELDS = ['email']
# pasword field is inherited with a hashing function defined in the settings file
objects = UserManager()
def __str__(self): # makes it easy to display the username
return self.username
class User(AbstractBaseUser, PermissionsMixin):
# auth field
mobile_phone = models.CharField(_('mobile phone'),
unique=True,
max_length=30,
validators=[
mobile_phone_number,
])
email = models.EmailField(_('email address'), blank=True)
first_name = models.CharField(_('first name'), max_length=30, blank=True)
last_name = models.CharField(_('last name'), max_length=30, blank=True)
date_joined = models.DateTimeField(_('date joined'), auto_now_add=True)
is_active = models.BooleanField(_('active'), default=True)
is_staff = models.BooleanField(
_('staff status'),
default=False,
help_text=_(
'Designates whether the user can log into this admin site.'),
)
turnes_person_id = models.IntegerField("ID клиента в БД Turnes",
blank=True,
null=True)
changed_default_password = models.BooleanField(
"Стандартный пароль из sms был изменен", default=False)
ready_for_turnes = models.BooleanField("Анкета полностью заполнена",
default=False)
objects = UserManager()
USERNAME_FIELD = 'mobile_phone'
REQUIRED_FIELDS = []
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def get_full_name(self):
'''
Returns the first_name plus the last_name, with a space in between.
'''
full_name = '%s %s' % (self.first_name, self.last_name)
return full_name.strip()
def get_short_name(self):
'''
Returns the short name for the user.
'''
return self.first_name
class User(AbstractBaseUser, PermissionsMixin):
email = models.EmailField(
_('email'),
unique=True,
blank=True,
)
first_name = models.CharField(_('name'), max_length=30, blank=True)
last_name = models.CharField(_('surname'), max_length=30, blank=True)
date_joined = models.DateTimeField(_('registered'), auto_now_add=True)
is_staff = models.BooleanField(_('is_staff'), default=False)
is_active = models.BooleanField(_('is_active'), default=False)
user_type = models.CharField(_('user_type'),
choices=USER_TYPE,
default=1,
max_length=50)
uuid = models.CharField(max_length=500, blank=True)
objects = UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = []
def save(self, *args, **kwargs):
super().save(*args, **kwargs)
if not self.uuid:
h = hashlib.md5(bytes(self.email, encoding='utf8'))
self.uuid = h.hexdigest()
self.save()
self.email_user(
'Hello',
f'Activate: http://localhost:8080//activate_email/{self.id}/{self.uuid}'
)
def __str__(self):
return f'{self.email} ID {self.id}'
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def get_full_name(self):
return f'{self.first_name} {self.last_name}'
def email_user(self, subject, message, from_email=None, **kwargs):
send_mail(subject, message, from_email, [self.email], **kwargs)
def send(self):
send_mail('Subject here',
'Here is the message.',
'*****@*****.**', [self.email],
fail_silently=False)
class User(AbstractBaseUser, PermissionsMixin):
"""
Change the default User Model beahavier to login with 'email'.
"""
email = models.EmailField(_('email address'), max_length=255, unique=True)
first_name = models.CharField(_('first name'), max_length=30, blank=True)
last_name = models.CharField(_('last name'), max_length=30, blank=True)
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 account'
))
date_joined = models.DateTimeField(_('date joined'), default=timezone.now)
is_trusty = models.BooleanField(
_('trusty'),
default=False,
help_text=_('Designates whether this user has confirmed his account.'))
USERNAME_FIELD = 'email' # Set email as a default login field
REQUIRED_FIELDS = []
objects = UserManager()
def __str__(self):
return self.email
@property
def get_full_name(self):
return f'{self.first_name} {self.last_name}'.strip()
@property
def get_short_name(self):
return self.first_name
def email_user(self, subject, message, from_email=None):
send_mail(subject, message, from_email, [self.email])
class Meta:
verbose_name = _('User')
verbose_name_plural = _('Users')
db_table = 'user'
class User(AbstractBaseUser, PermissionsMixin):
# Base
email = models.EmailField(
verbose_name=_('Email'), max_length=255, unique=True
)
first_name = models.CharField(verbose_name=_('First Name'), max_length=50)
last_name = models.CharField(verbose_name=_('Last Name'), max_length=50)
# Permissions
is_active = models.BooleanField(verbose_name=_('Active'), default=True)
is_staff = models.BooleanField(verbose_name=_('Staff'), default=False)
is_verified = models.BooleanField(verbose_name=_('Verified'), default=False)
# Image
image = models.ImageField(
verbose_name=_('Image'),
upload_to=set_user_images_upload_path, null=True, blank=True
)
objects = UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['first_name', 'last_name']
class Meta:
verbose_name = _('User')
verbose_name_plural = _('Users')
def __str__(self):
return self.get_full_name()
def get_full_name(self):
return '{first_name} {last_name}'.format(
first_name=self.first_name, last_name=self.last_name
)
def get_short_name(self):
return '{first_name}'.format(first_name=self.first_name)
def image_prev(self):
if self.image:
return '<img src="%s" style="max-height: 200px; ' \
'background-color:rgba(0, 0, 0, 0.1);"/>' % (
settings.MEDIA_URL + self.image.name
)
else:
return _('Not Found!')
image_prev.short_description = _('Preview')
image_prev.allow_tags = True
class User(AbstractBaseUser, PermissionsMixin):
email = models.EmailField('Почта', max_length=60, unique=True)
username = models.CharField('Имя пользователя', max_length=50, unique=True)
first_name = models.CharField('Имя', max_length=70)
last_name = models.CharField('Фамилия', max_length=70)
avatar = models.ImageField(
'Аватар пользователя',
upload_to='users/avatars/',
null=True,
blank=True,
)
about_author = models.TextField(verbose_name='О себе', max_length=700)
date_joined = models.DateTimeField('Дата регистрации', auto_now_add=True)
email_timestamp = models.IntegerField(
'Переотправление письма',
default=0,
help_text='Время до повторной отправки письма')
is_active = models.BooleanField('Аккаунт активирован', default=False)
is_staff = models.BooleanField('Админ', default=False)
objects = UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ('username', 'first_name', 'last_name')
class Meta:
verbose_name = 'Пользователь'
verbose_name_plural = 'Пользователи'
def __str__(self):
if self.first_name and self.last_name:
return f"{self.first_name} {self.last_name}"
return self.email
def email_user(self, subject, message, from_email=None, **kwargs):
""" For sending email to user """
send_mail(subject, message, from_email, [self.email], **kwargs)
def update_email_timestamp(self):
self.email_timestamp = int(datetime.now().timestamp() + 60)
# TODO оптимизировать сохранение
self.save()
def get_full_name(self):
return f"{self.first_name} {self.last_name}"
class User(AbstractBaseUser, PermissionsMixin):
TYPES = Choices(
('manager', 'MANAGER', _('Manager')),
('repairer', 'REPAIRER', _('Repairer')),
)
email = models.EmailField(verbose_name=_('email'), unique=True)
type = models.CharField(verbose_name=_('type'),
max_length=20,
choices=TYPES)
date_joined = models.DateTimeField(verbose_name=_('date joined'),
auto_now_add=True)
is_active = models.BooleanField(verbose_name=_('is active'), default=True)
is_staff = models.BooleanField(
_('staff status'),
default=False,
help_text=_(
'Designates whether the user can log into this admin site.', ),
)
objects = UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = []
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def __str__(self):
return self.email
def get_full_name(self):
raise NotImplementedError()
def get_short_name(self):
return self.email
@staticmethod
def send_sms(body, sms_to):
client = Client(
settings.TWILIO_ACCOUNT_SID,
settings.TWILIO_AUTH_TOKEN,
)
client.messages.create(
to=str(sms_to),
from_=settings.TWILIO_TEST_PHONE_NUMBER,
body=body,
)
class User(AbstractBaseUser, PermissionsMixin):
GENDER = (
(0, _('none')),
(1, _('male')),
(2, _('female')),
)
email = models.EmailField(_('email adress'),
max_length=255,
unique=True,
db_index=True)
first_name = models.CharField(_('first name'), max_length=255, blank=True)
last_name = models.CharField(_('last name'), max_length=255, blank=True)
is_staff = models.BooleanField(_('staff status'), default=False)
is_active = models.BooleanField(_('active'), default=True)
created_at = models.DateField(_('created at'), auto_now_add=True)
phone = models.CharField(_('phone'), max_length=15)
avatar = models.ImageField(upload_to=upload_to_users,
verbose_name=_('Avatar'),
blank=True)
gender = models.IntegerField(choices=GENDER,
verbose_name=_('Gender'),
blank=True,
null=True)
age = models.PositiveSmallIntegerField(verbose_name=_('Age'),
null=True,
blank=True)
USERNAME_FIELD = 'email'
objects = UserManager()
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def get_full_name(self):
"""
Returns the first_name plus the last_name, with a space in between.
"""
full_name = '%s %s' % (self.first_name, self.last_name)
return full_name.strip()
def get_short_name(self):
"""
Returns the short name for the user.
"""
return self.first_name
class User(AbstractBaseUser, PermissionsMixin):
"""
A custom user model for the site.
Fields
------
username : django.db.models.CharField
The user's username. This is the field they use to authenticate to
the site.
email : django.db.models.EmailField
The user's email address.
date_joined : django.db.models.DateTimeField
The date on which the user joined the site. Defaults to the time at
which create_user() is called.
is_active : django.db.models.BooleanField
Whether or not the user's account has been locked.
is_staff : django.db.models.BooleanField
Whether or not the user is a staff member for the site. Staff members
have higher administrative abilities than regular users. Being a staff
member does not imply being a superuser, which provides a higher level
of permissions.
"""
USERNAME_FIELD = "username"
REQUIRED_FIELDS = ["email"]
### User fields
username = models.CharField(max_length=MAX_USERNAME_LENGTH,
unique=True,
blank=False)
email = models.EmailField(max_length=MAX_EMAIL_ADDRESS_LENGTH,
unique=True,
blank=False)
date_joined = models.DateTimeField(default=timezone.now)
is_active = models.BooleanField(default=True)
### Permissions
is_staff = models.BooleanField(default=False)
### Manager object
# UserManager is used to create new users and superusers. It validates all
# of the user's fields before creating the user
objects = UserManager()
class User(AbstractBaseUser, PermissionsMixin):
"""Email and password are required. Other fields are optional."""
email = models.EmailField(_("email address"), unique=True)
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."),
)
date_joined = models.DateTimeField(_("date joined"), default=timezone.now)
USERNAME_FIELD = "email"
EMAIL_FIELD = "email"
REQUIRED_FIELDS: List[str] = []
objects = UserManager()
class Meta:
"""Model meta options."""
verbose_name = _("user")
verbose_name_plural = _("users")
swappable = "AUTH_USER_MODEL"
class JSONAPIMeta:
"""JSONAPI meta information."""
resource_name = "users"
def get_full_name(self):
"""Return the email (this method is required)."""
return self.email
def get_short_name(self):
"""Return the email (this method is required)."""
return self.email
def email_user(self, subject, message, from_email=None, **kwargs):
"""Send an email to this User."""
send_mail(subject, message, from_email, [self.email], **kwargs)
class User(AbstractUser):
"""Класс AskRegistration используется для описания модели хранящей
временные коды регистрации.
Родительский класс -- AbstractUser.
Атрибуты класса
--------
PK <-- Review, Comment
bio : models.CharField()
о пользователе
email : models.EmailField()
емейл пользователя
confirmation_code : models.CharField()
сгенерированный код подтверждения
created_at : models.DateTimeField()
дата и время создания пользователя
updated_at : models.DateTimeField()
дата и время создания пользователя
"""
class Role(models.TextChoices):
"""Класс Role используется для определния допустимых пользовательских
ролей."""
USER = '******', _('Пользователь')
MODERATOR = 'moderator', _('Модератор')
ADMIN = 'admin', _('Администратор')
bio = models.CharField(max_length=1000, null=True, blank=True)
email = models.EmailField(db_index=True, unique=True)
role = models.CharField(
max_length=10,
choices=Role.choices,
default=Role.USER,
)
updated_at = models.DateTimeField(auto_now=True)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username']
objects = UserManager()
class Meta:
ordering = ('id', )
def __str__(self):
""" Строковое представление модели (отображается в консоли) """
return self.email
class User(AbstractUser):
"""
Custom user model for authentication instead of usernames.
"""
username = None
email = models.EmailField(_('email address'), max_length=30, db_index=True, unique=True)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = []
objects = UserManager()
phone = models.CharField(max_length=13, blank=True)
def __str__(self):
return self.email
class User(AbstractUser):
"""Implementacion custom de usuario para modificar
flujo de creacion y activacion de usuario"""
username = None
password = models.CharField(max_length=128, null=True)
email = models.EmailField('Email', unique=True)
phone_number = models.CharField('Numero Telefono', max_length=15)
objects = UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['first_name', 'last_name', 'phone_number']
def __str__(self):
return self.username