class User(AbstractUser):
email = EmailField(unique=True, verbose_name='email address')
trusted = BooleanField(null=True)
objects = CustomUserManager()
REQUIRED_FIELDS = []
USERNAME_FIELD = 'email'
def get_absolute_url(self):
return reverse('user_detail', args=(self.id, ))
def __str__(self):
if self.is_staff:
return f'👮{self.username}'
if self.trusted:
return f'✨{self.id}'
return f'{self.id}'
def revisions_count(self):
return self.vehiclerevision_set.count()
def edits_count(self):
return self.vehicleedit_set.count()
def approved_count(self):
return self.vehicleedit_set.filter(approved=True).count()
def disapproved_count(self):
return self.vehicleedit_set.filter(approved=False).count()
def pending_count(self):
return self.vehicleedit_set.filter(approved=None).count()
class User(models.Model):
email = EmailField(max_length=63, unique=True)
firstname = CharField(max_length=63, blank=True, null=True)
lastname = CharField(max_length=63, blank=True, null=True)
pseudonym = CharField(max_length=63, blank=True, null=True)
password = CharField(max_length=63, blank=True,
null=True) # old; should be null
salt = CharField(max_length=32, blank=False,
null=True) # new secure authentication
saltedhash = CharField(max_length=128, blank=False,
null=True) # new secure authentication
confkey = CharField(max_length=63, blank=True, null=True)
guest = BooleanField(default=False)
valid = BooleanField(default=False)
def __unicode__(self):
return "%s %s: %s %s <%s>" % (self.__class__.__name__, self.id,
self.firstname, self.lastname,
self.email)
# Returns 'True' if password is correct, 'False' othrewise
def authenticate(self, password):
user_hash = hashlib.sha512(
password.encode('ascii', 'xmlcharrefreplace') +
self.salt).hexdigest()
return (self.saltedhash == user_hash)
# Updates 'salt' and 'saltedhash' to correspond to new password
# this method does notcall 'save'
def set_password(self, password):
self.salt = uuid.uuid4().hex
self.saltedhash = hashlib.sha512(
password.encode('ascii', 'xmlcharrefreplace') +
self.salt).hexdigest()
return
class Coordinator(models.Model):
'''A coordinator in one role.'''
source = ForeignKey(Source, on_delete=models.CASCADE)
name = CharField(max_length=64)
email = EmailField()
url = URLField()
class User(Model):
"""
User Details
"""
firebase = CharField('firebaseID',
max_length=128,
null=False,
unique=True,
primary_key=True,
blank=False)
username = CharField('username',
max_length=255,
null=False,
unique=True,
blank=False)
phone = CharField('phone', max_length=13, null=False, unique=False)
email = EmailField('email', unique=True)
firstName = CharField('firstName', max_length=255, null=False, blank=False)
lastName = CharField('lastName', max_length=255, blank=True, null=True)
def __str__(self) -> str:
return self.username
class User(AbstractBaseUser):
"""Overridden django user model."""
EMAIL_FIELD = "email"
USERNAME_FIELD = "email"
REQUIRED_FIELDS = ()
email = EmailField(_("email address"), unique=True)
group = ForeignKey(Group, CASCADE, related_name="users")
objects = UserManager()
deleted = BooleanField(default=False)
@property
def is_active(self):
"""
Check if the user is deleted or not.
:return: Whether or not this user is deleted.
:rtype: bool
"""
return not self.deleted
def clean(self):
"""
Overridden because there is no real username.
"""
self.email = self.__class__.objects.normalize_email(self.email)
class EmailLog(Model):
email_from = EmailField(verbose_name=_('email from'))
email_to = TextField(verbose_name=_('email to'))
hidden_copy = BooleanField(default=False, choices=BOOLEAN_CHOICES, verbose_name=_('has attachment'))
subject = TextField(verbose_name=_('subject'))
body = TextField(verbose_name=_('body'))
body_html = BooleanField(default=False, choices=BOOLEAN_CHOICES, verbose_name=_('body is html '))
has_attachment = BooleanField(default=False, choices=BOOLEAN_CHOICES, verbose_name=_('has attachment'))
register_datetime = DateTimeField(auto_now_add=True, verbose_name=_('register datetime'))
sended = BooleanField(default=False, choices=BOOLEAN_CHOICES, verbose_name=_('sended'))
sended_datetime = DateTimeField(null=True, blank=True, verbose_name=_('sended datetime'))
error_quantity = PositiveIntegerField(default=0, verbose_name=_('error quantity'))
exceeded_max_retry = BooleanField(default=False, choices=BOOLEAN_CHOICES, verbose_name=_('exceeded max retry'))
def __str__(self):
return u'{0}'.format(self.subject)
class Meta:
ordering = ['register_datetime', 'subject']
verbose_name_plural = _('emails logs')
verbose_name = _('email log')
class User(AbstractUser):
class Meta:
verbose_name = '用户'
verbose_name_plural = verbose_name
first_name = None
last_name = None
username = FixedCharField(
max_length=20,
null=False,
blank=False,
charset='utf8mb4',
collade='utf8mb4_general_ci',
verbose_name='昵称'
)
is_superuser = BooleanField(null=False, default=True)
is_staff = BooleanField(null=False, default=False)
is_active = BooleanField(null=False, default=True)
email = EmailField(unique=True)
img = CharField(
null=True, max_length=255, blank=False, verbose_name='头像'
)
auth = ManyToManyField(
to=Auth,
db_table='user_auth',
db_constraint=False,
)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username', ]
LOGIN_USERNAME_FIELDS = ['email', ]
objects = UserManager()
class Restaurant(models.Model):
restaurant_ID = AutoField(primary_key=True)
owner = models.ForeignKey(UserProfile,
on_delete=models.CASCADE,
null=True,
blank=True)
name = CharField(max_length=100)
slug = models.SlugField(unique=True)
address = CharField(max_length=100, blank=True, null=True)
overview = CharField(max_length=100)
detailed = CharField(max_length=300, blank=True, null=True)
phone_number = IntegerField(blank=True, null=True)
email_address = EmailField(blank=True, null=True)
rating = IntegerField(default=0)
price = IntegerField(default=0)
picture = models.ImageField(upload_to='images/', null=True)
lat = FloatField(default=55.8642)
lng = FloatField(default=-4.2518)
def save(self, *args, **kwargs):
self.slug = slugify(self.name)
super(Restaurant, self).save(*args, **kwargs)
def __str__(self):
return self.name
class User(AbstractBaseUser, PermissionsMixin):
username = CharField(max_length=25,
blank=True,
null=True,
unique=True,
db_index=True)
email = EmailField(unique=True, db_index=True)
is_superuser = BooleanField(default=False)
is_staff = BooleanField(default=False)
is_active = BooleanField(default=True)
first_name = CharField(max_length=100, blank=True, null=True)
last_name = CharField(max_length=100, blank=True, null=True)
created = DateTimeField(auto_now_add=True)
last_login = DateTimeField(auto_now=True)
objects = UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
def __str__(self) -> str:
return self.email
def has_perm(self, perm, obj=None):
"Does the user have a specific permission?"
# Simplest possible answer: Yes, always
return self.is_superuser
def has_module_perms(self, app_label):
"Does the user have permissions to view the app `app_label`?"
# Simplest possible answer: Yes, always
return self.is_superuser
class Contact(models.Model):
name = models.CharField(max_length=100)
email = EmailField()
subject = models.CharField(max_length=100)
message = models.TextField(max_length=100)
def __str__(self):
return self.name
class User(models.Model):
first_name=models.CharField(max_length=15)
last_name=models.CharField(max_length=15)
email=EmailField()
hashpass=models.CharField(max_length=115)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
objects = UserManager()
class User(AbstractUser):
email = EmailField(unique=True, verbose_name='email address')
REQUIRED_FIELDS = []
USERNAME_FIELD = 'email'
def get_absolute_url(self):
return reverse('user_detail', args=(self.id, ))
class User(models.Model): # old: users
email = EmailField(max_length=63, unique=True)
firstname = CharField(max_length=63, blank=True, null=True) # new
lastname = CharField(max_length=63, blank=True, null=True) # new
pseudonym = CharField(max_length=63, blank=True, null=True) # new
password = CharField(max_length=63, blank=True, null=True)
confkey = CharField(max_length=63, blank=True, null=True)
guest = BooleanField(default=False) # new
valid = BooleanField(default=False) # new
class Student(models.Model):
student_name = CharField(max_length=200, null=False)
role=CharField(max_length=200, default="student", null=True, blank=True)
email=EmailField(null=False, blank=False)
password = CharField(max_length=200,null=False)
classroom = models.ManyToManyField(ClassRoom,null=True, blank=True)
def __str__(self):
return "<id={}, student_name={}>".format(self.id,self.student_name)
class Teacher(models.Model):
teacher_name = CharField(max_length=200, null=False, blank=False)
role=CharField(max_length=200, default="teacher")
subject = CharField(max_length=200,null=False, blank=False)
email=EmailField(null=False, blank=False)
password=CharField(max_length=200,null=False, blank=False)
user = models.ForeignKey(User, on_delete=models.CASCADE)
def __str__(self):
return "<id={}, teacher_name={}>".format(self.id,self.teacher_name)
def valid_email_or_none(email):
ret = None
try:
if email:
validate_email(email)
if len(email) <= EmailField().max_length:
ret = email
except ValidationError:
pass
return ret
class UserRegisterForm(UserCreationForm):
email = EmailField()
class Meta:
model = User
fields =[
'username',
'email',
'password1',
'password2'
]
class User(db.Document, UserMixen):
id = IntegerField(primary_key=True)
username = StringField(unique=True)
email = EmailField(unique=True)
image_file = StringField(default='default.jpg')
password = StringField(default=True)
isAdmin = BooleanField(default=False)
posts = Relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class UserUpdateForm(forms.ModelForm):
email = EmailField(unique=True)
class Meta:
model = User
fields =[
'first_name',
'last_name',
'username',
'email'
]
class User(models.Model): # old: users
email = EmailField(max_length=63, unique=True)
firstname = CharField(max_length=63, blank=True, null=True) # new
lastname = CharField(max_length=63, blank=True, null=True) # new
pseudonym = CharField(max_length=63, blank=True, null=True) # new
password = CharField(max_length=63, blank=True, null=True)
confkey = CharField(max_length=63, blank=True, null=True)
guest = BooleanField(default=False) # new
valid = BooleanField(default=False) # new
def __unicode__(self):
return "%s %s: %s %s <%s>" % (self.__class__.__name__,self.id, self.firstname, self.lastname, self.email)
class User(AbstractUser):
# First Name and Last Name do not cover name patterns
# around the globe.
name = CharField(_("Name of User"), blank=True, max_length=255)
email = EmailField(_('email address'), unique=True)
USERNAME_FIELD = "email"
REQUIRED_FIELDS = []
def get_absolute_url(self):
return reverse("users:detail", kwargs={"username": self.username})
class User(models.Model):
"""Model for user data"""
email = EmailField(unique=True)
@property
# returns hash of inputted email
def magic_link(self):
return hash(self.email)
def __str__(self):
return "email: {0}\nhash: {1}".format(self.email, self.magic_link)
class LoginSerializer(ModelSerializer):
email = EmailField()
password = CharField()
class Meta:
model = User
fields = ['email', 'password']
read_only_fields = ['username', 'id']
extra_kwargs = {"password": {"write_only": True}}
def validate(self, data):
return data
class Profile(models.Model):
user = models.OneToOneField(User,
on_delete=models.CASCADE,
related_name="profile")
profile_image_thumbnail = ProcessedImageField(
blank=True,
upload_to='profile-images/',
processors=[ResizeToFill(80, 80)],
format='JPEG',
options={'quality': 85})
display_name = models.CharField(max_length=100)
email = EmailField(max_length=255, blank=True)
def __str__(self):
return f"{self.display_name}'s Profile"
class User(models.Model):
email = EmailField(max_length=100, unique=True)
first_name = CharField(max_length=100)
last_name = CharField(max_length=100)
password = CharField(max_length=100)
created_at = DateTimeField(auto_now_add=True)
updated_at = DateTimeField(auto_now=True)
#posted_jobs
#taken_jobs
objects = UserManager()
@property
def full_name(self):
return f"{self.first_name} {self.last_name}" #'%s %s' % (self.first_name, self.last_name)
class UserLoginSerializer(ModelSerializer):
token = CharField(blank=True, editable=False)
username = CharField(blank=True)
email = EmailField(blank=True)
class Meta:
model = User
fields = (
'username',
'email',
'password',
'token',
)
extra_kwargs = {'password':
{'write_only': True}
}
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
first_name = CharField(max_length=20, null=True)
last_name = CharField(max_length=20, null=True)
email = EmailField(max_length=100, null=True)
bio = models.TextField(max_length=500, blank=True)
zipcode = models.IntegerField(blank=True, null=True, default=00000)
place_id = CharField(max_length=100,
null=True,
default="ChIJowv49br0wokRBi5L14DyqTo"
) # google ID for zipcode/postal_code
skills = models.CharField(max_length=100,
choices=choices,
blank=True,
default=choices[0][0])
rate = models.IntegerField(null=True, blank=True)
image = CharField(max_length=200, blank=True, null=True)
class User(AbstractUser):
is_artist = BooleanField(default=False)
email = EmailField(max_length=100, unique=True, null=False)
photo = models.ImageField(default=None, null=True)
member_since = models.DateField(default=date.today)
def __str__(self):
return f"{self.id}, {self.username}, {self.is_artist}"
def serialize(self):
return {
'id': self.id,
'username': self.username,
'is_artist': self.is_artist,
}
class Meta:
ordering = ['id']
class Customer(models.Model):
customer_name = models.CharField(max_length=225,
help_text=("alphanumeric identifier"),
null=False,
blank=False)
contact_number = models.CharField(unique=True,
null=True,
blank=True,
max_length=17)
email = EmailField(max_length=30)
address = models.CharField(max_length=100,
blank=True,
null=True,
help_text="string")
created_at = models.DateTimeField(auto_now_add=True, null=True, blank=True)
def __str__(self):
return self.customer_name
class Business(models.Model):
business_name = models.CharField(max_length=50, blank=True)
email = EmailField(null=False)
user = models.ForeignKey(User, null=True, on_delete=models.Case)
hood = models.ForeignKey(Hood, null=True, on_delete=models.CASCADE)
def __str__(self):
return self.hood
def create_business(self):
self.save()
def delete_business(self):
self.delete()
def find_business(self, business_id):
self.search_by_id(id=business_id)
def update_business(self):
self.update()