def create(self, validated_data):
abc = 'abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'
user = super(UserSerializer, self).create(validated_data)
user.email = self.validated_data['email']
password = BaseUserManager().make_random_password(length=5,
allowed_chars=abc)
user.password = BaseUserManager(). \
make_random_password(length=5, allowed_chars=abc)
user.set_password(password)
if user.role == 'moderator':
user.is_staff = True
elif user.role == 'admin':
user.is_admin = True
user.save()
return user
class CustomUser(AbstractBaseUser, PermissionsMixin):
email = models.EmailField(_('email address'),
unique=True,
error_messages={
'unique':
_("A user with that email already exists."),
})
USERNAME_FIELD = 'email'
objects = BaseUserManager()
def __str__(self):
return self.email
is_staff = models.BooleanField(
_('staff status'),
default=True,
help_text=_(
'Designates whether the user can log into this admin site.'))
def get_full_name(self):
return self.email
def get_short_name(self):
return self.email
class Customer(AbstractBaseUser):
USERNAME_FIELD = 'email'
id = models.TextField(
primary_key=True,
default=_default_id
)
email = models.EmailField(unique=True)
first_name = models.TextField()
last_name = models.TextField()
gender = models.CharField(max_length=1)
country_code = models.CharField(max_length=3)
objects = BaseUserManager()
def as_dict(self):
return {
'id': self.id,
'email': self.email,
'first_name': self.first_name,
'last_name': self.last_name,
'gender': self.gender,
'country_code': self.country_code
}
class BaseUser(AbstractUser):
email = models.EmailField(max_length=255, unique=True, null=False)
objects = BaseUserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = [] # removes email from REQUIRED_FIELDS
def get_full_name(self):
return '{}, {}'.format(self.last_name, self.first_name)
def get_short_name(self):
return self.username
def set_username(self):
instances = BaseUser.objects.filter(first_name=self.first_name,
last_name=self.last_name).count()
# print("There are {} instances of '{} {}'".format(instances, self.first_name, self.last_name))
if instances:
# print("Appending '-{}' to new_user's username".format(instances+1))
self.username = '******'.format(self.first_name, self.last_name,
instances + 1)
else:
self.username = '******'.format(self.first_name, self.last_name)
# print('Username of {} {}: {}'.format(self.first_name, self.last_name, self.username))
self.save()
def __str__(self):
return self.email
class User(AbstractUser):
# history = HistoricalRecords() # done in translation.py
username_validator = UsernameValidator()
username = models.CharField(
_("username"),
primary_key=True,
# max_length=150,
max_length=20,
unique=True,
# help_text=_('Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.'),
help_text=_("Required. 20 characters or fewer. Letters, digits and _ only."),
validators=[username_validator],
error_messages={"unique": _("A user with that username already exists.")},
)
# MANAGERS
objects = BaseUserManager()
public_objects = PublicUserManager()
class Meta(AbstractUser.Meta):
ordering = ["-date_joined"]
def get_absolute_url(self):
return reverse("accounts:profile")
def get_avatar_url(self):
try:
return self.socialaccount_set.all()[0].get_avatar_url()
except:
return None
class User(AbstractBaseUser):
"""
User object for our app
"""
email = models.EmailField(
verbose_name='email address',
max_length=255,
unique=True,
)
is_admin = models.BooleanField(default=False)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
date_of_birth = models.DateField()
reliability = models.FloatField(default=0.0)
country = models.CharField(max_length=255)
first_name = models.CharField(max_length=255)
last_name = models.CharField(max_length=255)
display_name = models.CharField(max_length=255)
avatar = models.ImageField(upload_to="avatars", null=True)
bookmarks = models.ManyToManyField(Content)
upvotes = models.ManyToManyField(Rating, related_name="upvote_users")
downvotes = models.ManyToManyField(Rating, related_name="downvote_users")
objects = BaseUserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = [
'date_of_birth', 'first_name', 'last_name', 'display_name'
]
class User(AbstractBaseUser, PermissionsMixin):
USERNAME_FIELD = 'username'
account = m.ForeignKey('Account', related_name="users", null=False)
username = CharField255(unique=True, db_index=True)
email = m.EmailField(max_length=255, unique=True, db_index=True)
unread_events_count = m.IntegerField(null=False, default=0)
# indicates if user has complete signup process
# and can be logged into the app.
is_signup_complete = m.BooleanField(null=False, default=False)
# admin related fields
is_staff = m.BooleanField(default=False)
is_active = m.BooleanField(default=True)
objects = BaseUserManager()
def get_full_name(self):
return self.username
# for admin site purposes
def get_short_name(self):
return self.username
class User(AbstractBaseUser):
username = models.SlugField(primary_key=True)
name = models.CharField(max_length=255)
email = models.EmailField(
verbose_name="email address",
max_length=255,
unique=True,
)
organisation = models.ForeignKey("Organisation",
on_delete=models.CASCADE,
related_name="users")
is_active = models.BooleanField(default=True)
is_admin = models.BooleanField(default=False)
objects = BaseUserManager()
USERNAME_FIELD = "username"
def save(self, *args, **kwargs):
self.username = slugify(self.name)
super().save(*args, **kwargs)
def __str__(self):
return self.username
@property
def is_staff(self):
return self.is_admin
def has_perm(self, perm, obj=None):
return True
def has_module_perms(self, app_label):
return True
class CustomUser(AbstractBaseUser):
username = models.CharField(max_length=30, unique=True, default='user')
active = models.BooleanField(default=True)
quiz_creator = models.BooleanField(default=False)
USERNAME_FIELD = 'username'
objects = BaseUserManager()
def create_user(username, password):
user = CustomUser(username=username, password=password)
user.set_password(password)
try:
user.save()
return user
except (ValueError, IntegrityError):
return None
def __str__(self):
return f'Username: {self.username};\n Is_quiz_creator: {self.quiz_creator};'
@property
def get_username(self):
return self.username
@property
def is_quiz_creator(self):
return self.quiz_creator
@property
def is_active(self):
return self.active
class Profile(AbstractUser):
user_role = models.SmallIntegerField(choices=MAP_ROLES,
null=True,
blank=True)
slug = AutoSlugField(unique=True, populate_from='full_name')
about_me = models.TextField(blank=True)
created_datetime = models.DateTimeField(auto_now_add=True)
updated_datetime = models.DateTimeField(auto_now=True)
objects = BaseUserManager()
shortcuts = ProfileManager()
@property
def is_author(self):
return self.user_role == 1
@property
def is_editor(self):
return self.user_role == 2
@property
def is_administrator(self):
return self.user_role == 3
@property
def full_name(self):
return self.get_full_name()
@models.permalink
def get_absolute_url(self):
return ('author_detail', [str(self.slug)])
def __unicode__(self):
return self.full_name
class StoreItem(models.Model):
"""Represents an item of a Store"""
store_user = models.ForeignKey(StoreUserProfile,
on_delete=models.SET_NULL,
null=True,
related_name='store_items')
item_id = models.CharField(max_length=255,
primary_key=True,
default=uuid.uuid4())
item_name = models.CharField(max_length=30, blank=False, default="")
price = models.IntegerField(null=False, default=0)
popularity = models.IntegerField(null=False, default=0)
created_on = models.DateTimeField(auto_now_add=True, null=True)
objects = BaseUserManager()
def ___str___(self):
"""Returns the model as a string"""
return self.item_name
def get(self):
"""Returns the model as a json object"""
object = {
'item_name': self.item_name,
'price': self.price,
'popularity': self.popularity,
'created_on': self.created_on.strftime('%m%d%H')
}
return object
class BaseUser(AbstractBaseUser):
user_id = models.AutoField(primary_key=True)
# Displayed as Institution Name for Administrators
username = models.CharField(max_length=255, unique=True, null=False)
email = models.EmailField(max_length=255, unique=True, null=False)
mobile_number = models.CharField(max_length=40, unique=True, null=True)
landline_number = models.CharField(max_length=40, unique=True, null=True)
is_admin = models.BooleanField(default=False)
slug = models.SlugField(unique=True)
objects = BaseUserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username']
def get_full_name(self):
return self.email
def get_short_name(self):
return self.username
def get_profile(self):
return reverse('users:detail', kwargs={'slug': self.slug})
def __str__(self):
return self.email
class MyUser(AbstractBaseUser):
USERNAME_FIELD = 'my_username'
my_username = models.CharField(max_length=30)
objects = BaseUserManager()
class Meta:
abstract = False
class CustomUser(AbstractBaseUser):
email = models.EmailField(verbose_name='email address', max_length=255, unique=True)
custom_objects = BaseUserManager()
USERNAME_FIELD = 'email'
class Meta:
app_label = 'test_client_regress'
class AppUser(AbstractBaseUser):
email = models.EmailField(unique=True)
password = models.CharField(max_length=15)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = [email, password]
objects = BaseUserManager()
class CustomUserWithoutEmail(AbstractBaseUser):
username = models.CharField(max_length=255, unique=True)
objects = BaseUserManager()
USERNAME_FIELD = 'username'
class Meta:
app_label = 'tests'
class CustomUser(AbstractBaseUser):
email = models.EmailField(max_length=255, unique=True)
objects = BaseUserManager()
USERNAME_FIELD = 'email'
class Meta:
app_label = 'tests'
class User(Abstract, AbstractBaseUser):
is_manager = models.BooleanField(default=False, verbose_name="Is manager?")
email = models.EmailField(_('email address'), max_length=254, unique=True)
USERNAME_FIELD = 'email'
objects = BaseUserManager()
class Meta:
verbose_name = "User"
verbose_name_plural = "Users"
class Users(AbstractBaseUser):
username = models.CharField(max_length=128)
email = models.EmailField(max_length=50, unique=True)
password = models.CharField(max_length=128)
first_name = models.CharField(blank=True, max_length=30)
last_name = models.CharField(blank=True, max_length=20)
add_id = models.ForeignKey(Ad, on_delete=True)
objects = BaseUserManager()
USERNAME_FIELD = 'username'
class MyIntUser(AbstractBaseUser):
USERNAME_FIELD = "my_username"
my_username = models.IntegerField()
objects = BaseUserManager()
class Meta:
abstract = False
class User(AbstractBaseUser):
email = models.EmailField(max_length=255, unique=True)
objects = BaseUserManager()
USERNAME_FIELD = 'email'
def __str__(self):
return self.email
class IsActiveTestUser1(AbstractBaseUser):
"""
This test user class and derivatives test the default is_active behavior
"""
username = models.CharField(max_length=30, unique=True)
custom_objects = BaseUserManager()
USERNAME_FIELD = 'username'
class User(AbstractBaseUser):
username = models.CharField(max_length=255, unique=True)
password = models.CharField(max_length=255)
USERNAME_FIELD = 'username'
PASSWORD_FIELD = 'password'
objects = BaseUserManager()
class User(AbstractBaseUser, PermissionsMixin):
"""Custom user model that supports using email instead of username"""
email = models.EmailField(max_length=255, unique=True)
name = models.CharField(max_length=255)
is_active = models.BooleanField(default=True)
is_staff = models.BooleanField(default=False)
objects = BaseUserManager()
USERNAME_FIELD = 'email'
class User(AbstractBaseUser):
objects = BaseUserManager()
USERNAME_FIELD = 'email'
EMAIL_FIELD = 'email'
name = models.CharField('Name', max_length=150)
email = models.EmailField("Email", unique=True)
balance = models.DecimalField(default=Decimal(5000),
**settings.MONEY_FIELD_ARGS)
class CustomUserUUID(AbstractBaseUser):
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
email = models.EmailField(max_length=255, unique=True)
objects = BaseUserManager()
USERNAME_FIELD = 'email'
class Meta:
app_label = 'tests'
class User(AbstractBaseUser):
"""Represents a user object in our system."""
email = models.EmailField(max_length=255, unique=True, null=False)
login = models.CharField(max_length=255, unique=True, null=False)
created_at = models.DateTimeField(auto_now_add=True)
avatar = models.ImageField()
objects = BaseUserManager()
USERNAME_FIELD = 'login'
class User(AbstractBaseUser):
mobile = models.CharField(validators=[phone_regex],
max_length=15,
unique=True,
blank=True,
null=True)
mobile_verified = models.BooleanField(default=False)
objects = BaseUserManager()
USERNAME_FIELD = 'mobile'
class Publisher(models.Model):
"""
Schema for publisher instances.
"""
name = models.TextField(null=False)
created_at = models.DateField(editable=False, auto_now=True)
objects = BaseUserManager()
def __str__(self):
"""Return string representation of our publisher"""
return self.name
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
