class User(auth_models.AbstractUser):
objects = auth_models.UserManager()
avatar = models.ImageField(upload_to='photos', blank=True)
status = models.CharField(max_length=1000, blank=True, default="")
city = models.CharField(max_length=50, blank=True, default="")
birthday = models.DateField(blank=True, null=True)
gender = models.CharField(max_length=1,
blank=True,
default='',
choices=(('M', 'Male'), ('F', 'Female'),
('', '---')))
about = models.TextField(blank=True, default="")
friends = models.ManyToManyField('self', symmetrical=False)
def get_friends(self, check_common_with=None):
friends = self.friends.filter(friends=self)
if isinstance(check_common_with, auth_models.AbstractUser) \
and check_common_with.id != self.id:
user = check_common_with
friends = friends.annotate(
is_common=Count('friends', filter=Q(
id__in=user.get_friends())))
return friends
def get_posted_photos(self):
return self.posted_photos.select_related('photo').all()
def get_posted_videos(self):
return self.posted_videos.select_related('video').all()
def sent_friend_request_to(self, user):
return self.friends.filter(id=user.id).exists()
class CustomUser(AbstractBaseUser, auth_models.PermissionsMixin):
username_validator = ASCIIUsernameValidator()
"""カスタムユーザーモデル."""
class Meta:
db_table = 'custom_user'
#ユーザ基本情報
username = models.CharField(max_length=10,unique=True)
email = models.EmailField(unique=False, blank=True)
first_name = models.CharField(max_length=30, blank=True)
last_name = models.CharField(max_length=150, blank=True)
#ユーザプロフィール詳細
profile = models.CharField(max_length=10000, blank=True)
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
# Default Permission
is_staff = models.BooleanField(default=False)
is_admin = models.BooleanField(default=False)
is_active = models.BooleanField(default=True)
is_superuser = models.BooleanField(default=False)
objects = auth_models.UserManager()
def __str__(self):
return self.username
class User(AbstractUser):
belongs = models.ManyToManyField(Grade, through='Belong')
objects = auth_models.UserManager()
avatar = models.ImageField(upload_to="avatar", null=True, blank=True)
avatar_thumbnail = ImageSpecField(source="avatar",
processors=[ResizeToFill(100, 100)],
format='PNG',
options={'quality': 80})
def get_full_name(self):
self.get_username()
return '%s %s' % (self.last_name, self.first_name)
class Muser(auth_models.User):
objects = auth_models.UserManager()
gender = models.PositiveSmallIntegerField(blank=True, default=0) # 1: male, 2: female
birthdate = models.DateField(blank=True, null=True)
push_token = models.CharField(max_length=200, blank=True, null=True)
cluster = models.PositiveSmallIntegerField(blank=True, null=True)
recommended = models.ManyToManyField('chatbot.Music')
class Meta:
verbose_name = 'Muser'
def __str__(self):
return self.username
class User(auth_models.PermissionsMixin, auth_models.AbstractBaseUser):
username = models.CharField(
_('username'),
max_length=30,
unique=True,
help_text=_('Required. 30 characters or fewer. Letters, numbers and '
'@/./+/-/_ characters'),
validators=[
validators.RegexValidator(re.compile(r'^[\w.@+-]+$', re.U),
_('Enter a valid username.'), 'invalid')
])
email = models.EmailField(_('email address'), 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 accounts.'))
date_joined = models.DateTimeField(_('date joined'), default=timezone.now)
avatar = models.ImageField(upload_to='avatars', blank=True, null=True)
rank = models.CharField(max_length=255,
default='',
blank=True,
null=True,
verbose_name=_('rank'))
show_played_games = models.BooleanField(
default=True, verbose_name=_('show played games'))
show_played_characters = models.BooleanField(
default=True, verbose_name=_('show played characters'))
show_online_status = models.BooleanField(
default=True, verbose_name=_('show on-line status'))
hide_trustmarks = models.BooleanField(default=False,
verbose_name=_('hide trustmarks'))
signature = models.TextField(max_length=400,
default='',
blank=True,
verbose_name=_('signature'))
compact_text = models.BooleanField(default=False,
verbose_name=_('compact text'))
icq = models.CharField(default='',
blank=True,
max_length=12,
verbose_name=_('ICQ'))
skype = models.CharField(default='',
blank=True,
max_length=50,
verbose_name=_('skype'))
sex = models.SmallIntegerField(
default=USER_SEX_UNDEFINED,
verbose_name=_(u'sex'),
choices=USER_SEX_CHOICES,
)
game_inline = models.SmallIntegerField(
default=USER_GAME_INLINE_TIME,
blank=False,
verbose_name=_(u'Show in game'),
choices=USER_GAME_INLINE_CHOICES,
)
animation_speed = models.PositiveIntegerField(
default=1000,
blank=False,
verbose_name=_(u'Animation speed'),
)
vk_profile = models.ForeignKey(VK_Profile,
models.PROTECT,
blank=True,
null=True)
not_readed_messages = models.SmallIntegerField(
default=0,
blank=False,
editable=False,
verbose_name=_(u'Show in game'),
)
last_read_pm_id = models.PositiveIntegerField(
default=0,
blank=False,
editable=False,
)
stories_author = models.PositiveIntegerField(
default=0,
blank=False,
editable=False,
)
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
objects = auth_models.UserManager()
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def __str__(self):
v = self.username
return u'%s' % (v, )
def get_absolute_url(self):
return urls.reverse('players:player_details',
kwargs={'player_id': self.pk})
def get_full_name(self):
return self.username
def get_short_name(self):
return self.username
def email_user(self, subject, message, from_email=None):
send_mail(subject, message, from_email, [self.email])
def full_stars(self):
from tulius.stories.models import Variation, Role
from tulius.games import models as game_models
from tulius.players.models import stars
self.full_stars_cache = getattr(self, 'full_stars_cache', None)
if self.full_stars_cache is not None:
return self.full_stars_cache
self.full_stars_cache = 0
variation_ids = [
role['variation'] for role in Role.objects.filter(
user=self).values('variation').distinct()
]
variations = Variation.objects.filter(id__in=variation_ids)
games_played = variations.filter(game__status__in=[
game_models.GAME_STATUS_COMPLETED,
game_models.GAME_STATUS_COMPLETED_OPEN
]).count()
big_stars = int(games_played / 100)
games_played -= big_stars * 100
small_stars = 0
for star in stars.stars_list:
if star <= games_played:
small_stars += 1
else:
break
self.full_stars_cache = 'b' * big_stars + 's' * small_stars + 'e' * (
stars.stars_count - small_stars)
return self.full_stars_cache
new_invites_cache = None
def new_invites(self):
from tulius.games.models import GAME_INVITE_STATUS_NEW, GameInvite
if self.new_invites_cache is None:
self.new_invites_cache = GameInvite.objects.filter(
user=self, status=GAME_INVITE_STATUS_NEW)
return self.new_invites_cache
def send_pm(self, sender, body):
from tulius.pm.models import PrivateMessage
pm = PrivateMessage(sender=sender, receiver=self, body=body)
pm.save()
def update_not_readed(self):
from tulius.pm.models import PrivateMessage
count = PrivateMessage.objects.filter(
receiver=self, is_read=False, removed_by_receiver=False).count()
self.not_readed_messages = count
last = PrivateMessage.objects.filter(receiver=self,
is_read=True).order_by('-id')[:1]
if last:
self.last_read_pm_id = last[0].pk
self.save()
def to_json(self, detailed=False):
data = {
'id': self.pk,
'title': html.escape(self.username),
'url': self.get_absolute_url(),
}
if detailed:
data.update({
'sex': self.sex,
'avatar': self.avatar.url if self.avatar else '',
'full_stars': self.full_stars(), # TODO optimize it
'rank': html.escape(self.rank),
'stories_author': self.stories_author,
'signature': bbcodes.bbcode(self.signature),
})
signals.user_to_json.send(User,
instance=self,
response=data,
detailed=detailed)
return data
class CustomUser(auth_models.AbstractBaseUser, auth_models.PermissionsMixin,
mixins.DirtyMixin):
"""
A custom user class that basically mirrors Django's `AbstractUser` class
and doesn't force `first_name` or `last_name` with sensibilities for
international names.
http://www.w3.org/International/questions/qa-personal-names
"""
username = models.CharField(
_('username'),
max_length=30,
unique=True,
help_text=_('Required. 30 characters or fewer. Letters, numbers and '
'@/./+/-/_ characters'),
validators=[
validators.RegexValidator(re.compile(r'^[a-zA-Z0-9_.@+-]+$'),
_('Enter a valid username.'), 'invalid')
])
full_name = models.CharField(_('full name'), max_length=254, blank=True)
# FIXME: This field looks unused
short_name = models.CharField(_('short name'), max_length=30, blank=True)
email = models.EmailField(_('email address'), max_length=254, 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,
db_index=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)
avatar_url = models.CharField(_('avatar URL'), max_length=256, blank=True)
objects = auth_models.UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def __str__(self):
return self.username
# FIXME: replace with django.urls.reverse(..)
def get_absolute_url(self):
return "/users/%s/" % urlquote(self.username)
# FIXME: This method implementation is optional since Django 2.0
def get_full_name(self):
return self.full_name.strip()
# FIXME: This method implementation is optional since Django 2.0
def get_short_name(self):
return self.short_name.strip()
def get_subscriptions(self):
return [{
'id': g.id,
'github_user': g.github_user,
'github_repo': g.github_repo,
} for g in self.subscriptions.all()]
def get_starred(self):
return [{
'id': g.id,
'github_user': g.repository.github_user,
'github_repo': g.repository.github_repo,
} for g in self.starred.select_related('repository').all()]
class User(auth_models.AbstractBaseUser, auth_models.PermissionsMixin):
username = models.CharField(_('username'),
max_length=60,
unique=True,
help_text=USERNAME_HELP,
validators=[USERNAME_VALIDATOR],
error_messages={
'unique': _(USERNAME_NOT_UNIQUE),
})
email = models.EmailField(_('email address'),
unique=True,
error_messages={
'unique': EMAIL_NOT_UNIQUE,
})
is_staff = models.BooleanField(_('staff status'),
default=False,
help_text=IS_STAFF_HELP)
is_active = models.BooleanField(_('active'),
default=True,
help_text=IS_ACTIVE_HELP)
date_joined = models.DateTimeField(editable=False, default=timezone.now)
get_notifications = models.BooleanField(
verbose_name=_('Send me email notifications'),
default=True,
help_text=GET_NOTIFICATIONS_HELP)
_avatar = fields.ConfiguredImageField(
'avatar',
upload_to='users/images',
blank=True,
verbose_name=_('Avatar picture'),
)
description = models.CharField(
blank=True,
max_length=250,
verbose_name=_('Short description about yourself'),
help_text=_('Write a little bit about yourself. '
'(max. 250 characters)'))
twitter_handle = models.CharField(
blank=True,
max_length=15,
verbose_name=_('Twitter name'),
)
facebook_handle = models.CharField(
blank=True,
max_length=50,
verbose_name=_('Facebook name'),
)
instagram_handle = models.CharField(
blank=True,
max_length=30,
verbose_name=_('Instagram name'),
)
country = countries_fields.CountryField(
blank=True,
verbose_name=_('Country of residence'),
)
city = models.CharField(
blank=True,
max_length=80,
verbose_name=_('City of residence'),
)
birthdate = models.DateField(
blank=True,
null=True,
verbose_name=_('Date of birth'),
)
gender = models.CharField(
blank=True,
verbose_name=_('Gender'),
max_length=2,
choices=[
('M', _('Male')),
('F', _('Female')),
('T', _('Transgender')),
('TF', _('Transgender Female')),
('TM', _('Transgender Male')),
('I', _('Intersex')),
('GF', _('Gender Fluid')),
('O', _('Other')),
],
)
languages = models.CharField(
blank=True,
verbose_name=_('Languages'),
max_length=150,
help_text=_('Enter the languages you’re speaking.'))
timezone = models.CharField(blank=True,
verbose_name=_('Time zone'),
max_length=100,
choices=[(t, t) for t in common_timezones])
objects = auth_models.UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username']
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
def get_absolute_url(self):
from django.core.urlresolvers import reverse
return reverse('profile', kwargs={'slug': str(self.username)})
def __str__(self):
return self.get_full_name()
@property
def has_social_share(self):
return (self.twitter_handle or self.facebook_handle
or self.instagram_handle)
@property
def organisations(self):
return self.organisation_set.all()
@property
def avatar(self):
if self._avatar:
return self._avatar
@property
def default_avatar(self):
id = self.pk % 6
return static('images/penguin_{}.png'.format(id))
@property
def age(self):
today = date.today()
years_difference = today.year - self.birthdate.year
is_before_birthday = (today.month, today.day) < (self.birthdate.month,
self.birthdate.day)
elapsed_years = years_difference - int(is_before_birthday)
return elapsed_years
def get_full_name(self):
"""
Returns the first_name plus the last_name, with a space in between.
"""
full_name = '%s <%s>' % (self.username, self.email)
return full_name.strip()
def get_short_name(self):
"Returns the short name for the user."
return self.username
def signup(self, username, email, timezone, commit=True):
"""Update the fields required for sign-up."""
self.username = username
self.email = email
self.timezone = timezone
if commit:
self.save()
class Migration(migrations.Migration):
initial = True
dependencies = [("auth", "0011_update_proxy_permissions")]
operations = [
migrations.CreateModel(
name="User",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("password",
models.CharField(max_length=128, verbose_name="password")),
(
"last_login",
models.DateTimeField(blank=True,
null=True,
verbose_name="last login"),
),
(
"is_superuser",
models.BooleanField(
default=False,
help_text="Designates that this user has all "
"permissions without explicitly assigning "
"them.",
verbose_name="superuser status",
),
),
(
"username",
models.CharField(
max_length=150,
unique=True,
verbose_name="username",
error_messages={
"unique":
"A user with that username "
"already exists."
},
help_text="Required. 150 characters or fewer. "
"Letters, digits and @/./+/-/_ only.",
validators=[
auth_validators.UnicodeUsernameValidator()
],
),
),
(
"first_name",
models.CharField(blank=True,
max_length=30,
verbose_name="first name"),
),
(
"last_name",
models.CharField(blank=True,
max_length=150,
verbose_name="last name"),
),
(
"email",
models.EmailField(blank=True,
max_length=254,
verbose_name="email address"),
),
(
"is_staff",
models.BooleanField(
default=False,
help_text="Designates whether the user can log into "
"this admin site.",
verbose_name="staff status",
),
),
(
"is_active",
models.BooleanField(
default=True,
help_text="Designates whether this user should be "
"treated as active. Unselect this instead "
"of deleting accounts.",
verbose_name="active",
),
),
(
"date_joined",
models.DateTimeField(default=timezone.now,
verbose_name="date joined"),
),
(
"groups",
models.ManyToManyField(
blank=True,
help_text="The groups this user belongs to. "
"A user will get all permissions granted t"
"o each of their groups.",
related_name="user_set",
related_query_name="user",
to="auth.Group",
verbose_name="groups",
),
),
(
"user_permissions",
models.ManyToManyField(
blank=True,
help_text="Specific permissions for this user.",
related_name="user_set",
related_query_name="user",
to="auth.Permission",
verbose_name="user permissions",
),
),
],
options={
"verbose_name": "user",
"verbose_name_plural": "users",
"abstract": False,
},
managers=[("objects", auth_models.UserManager())],
),
migrations.CreateModel(
name='Tenant',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('created_at', models.DateTimeField(auto_now_add=True)),
('updated_at', models.DateTimeField(auto_now=True)),
('name', models.CharField(max_length=150, unique=True)),
('users',
models.ManyToManyField(related_name='tenants',
to='galaxy_auth.User')),
],
options={
'abstract': False,
},
),
]
class CustomUser(auth_models.AbstractBaseUser,
auth_models.PermissionsMixin,
mixins.DirtyMixin):
"""
A custom user class that basically mirrors Django's `AbstractUser` class
and doesn't force `first_name` or `last_name` with sensibilities for
international names.
http://www.w3.org/International/questions/qa-personal-names
"""
username = models.CharField(
_('username'),
max_length=30,
unique=True,
help_text=_('Required. 30 characters or fewer. Letters, numbers and '
'@/./+/-/_ characters'),
validators=[
validators.RegexValidator(re.compile('^[\w.@+-]+$'),
_('Enter a valid username.'),
'invalid')
])
full_name = models.CharField(_('full name'), max_length=254, blank=True)
short_name = models.CharField(_('short name'), max_length=30, blank=True)
email = models.EmailField(_('email address'), max_length=254, 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,
db_index=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)
# TODO(cutwater): Seem to be not used anymore.
# Consider removal of karma field.
karma = models.IntegerField(default=0, db_index=True)
avatar_url = models.CharField(
_('avatar URL'), max_length=256, blank=True)
cache_refreshed = models.BooleanField(
_('cache refreshed'), default=False)
objects = auth_models.UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def __str__(self):
return self.username
def get_absolute_url(self):
return "/users/%s/" % urlquote(self.username)
def get_full_name(self):
"""
Returns the first_name plus the last_name, with a space in between.
"""
full_name = self.full_name
return full_name.strip()
def get_short_name(self):
"""Returns the short name for the user."""
return self.short_name.strip()
def get_num_roles(self):
return self.roles.filter(active=True, is_valid=True).count()
def email_user(self, subject, message, from_email=None):
"""
Sends an email to this User.
"""
send_mail(subject, message, from_email, [self.email])
def hasattr(self, attr):
return hasattr(self, attr)
def get_subscriptions(self):
return [{
'id': g.id,
'github_user': g.github_user,
'github_repo': g.github_repo,
} for g in self.subscriptions.all()]
def get_starred(self):
return [{
'id': g.id,
'github_user': g.repository.github_user,
'github_repo': g.repository.github_repo,
} for g in self.starred.select_related('repository').all()]
def get_subscriber(self, github_user, github_repo):
try:
return self.subscriptions.get(
github_user=github_user,
github_repo=github_repo)
except exceptions.ObjectDoesNotExist:
return None
def get_stargazer(self, github_user, github_repo):
try:
star = self.starred.get(
repository__provider_namespace__name=github_user,
repository__name=github_repo)
return star
except exceptions.ObjectDoesNotExist:
return None
def is_connected_to_github(self):
connected = False
for account in self.socialaccount_set.all():
if account.provider == 'github':
connected = True
return connected
class User(auth_models.AbstractBaseUser, auth_models.PermissionsMixin):
username = models.CharField(
_('username'),
max_length=60,
unique=True,
help_text=_(
'Your username will appear publicly next to your posts.'),
validators=[
validators.RegexValidator(
USERNAME_REGEX, USERNAME_INVALID_MESSAGE, 'invalid')],
error_messages={
'unique': _('A user with that username already exists.')}
)
email = models.EmailField(
_('Email address'),
unique=True,
error_messages={
'unique': _('A user with that email address already exists.')}
)
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(
editable=False,
default=timezone.now
)
get_notifications = models.BooleanField(
verbose_name=_('Notifications'),
default=True,
help_text=_(
'Yes, I would like to be notified by e-mail about the start '
'and end of participation opportunities. This applies to all '
'projects I follow. I also receive an e-mail when someone '
'comments on one of my contributions.')
)
get_newsletters = models.BooleanField(
verbose_name=_('Newsletter'),
default=False,
help_text=_(
'Yes, I would like to receive e-mail newsletters about '
'the projects I am following.')
)
objects = auth_models.UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username']
@property
def organisations(self):
initiator_orgs = self.organisation_set.all()
if self.groups.all():
user_groups = self.groups.all().values_list('id', flat=True)
group_orgs = Organisation.objects \
.filter(groups__in=user_groups)
orgs = initiator_orgs | group_orgs
return orgs.distinct()
return initiator_orgs
def get_short_name(self):
return self.username
def get_full_name(self):
full_name = '%s <%s>' % (self.username, self.email)
return full_name.strip()
def signup(self, username, email, commit=True):
"""Update the fields required for sign-up."""
self.username = username
self.email = email
if commit:
self.save()
def get_absolute_url(self):
return reverse('profile', args=[str(self.username)])
class SvUserInfo(models.Model):
"""
Django base User class + extra Savane fields
Since it adds a field to Django's User objects, we prefix it by
'sv' to avoid clashes with other packages, C-style (ahem).
Using AutoOneToOneField to automatically create this extra data
for new users as soon as the field is accessed.
"""
class Meta:
ordering = ['user__username']
user = AutoOneToOneField(auth_models.User, primary_key=True)
# Migrated to 'first_name' and 'last_name' in auth.User
#realname = models.CharField(max_length=96)
# Old Savane can be Active/Deleted/Pending/Suspended/SQuaD
status_CHOICES = (
('A', _('Active')),
('D', _('Deleted')),
('P', _('Pending')),
('S', _('Suspended')),
#('SQD', _('Squad')), # TODO: implement squads more cleanly
)
status = models.CharField(max_length=3, choices=status_CHOICES, default='A')
# Unix mapping, used when populating a LDAP directory
uidNumber = models.IntegerField(default=0)
gidNumber = models.IntegerField(default=0)
# Used by trackers only but it could be used more widely
spamscore = models.IntegerField(null=True, blank=True)
# Confirm that user owns the e-mail the hash was sent to
email_hash_confirm = models.BigIntegerField(blank=True, null=True)
# Allow a user to counter-act an account hijack
email_hash_cancel = models.BigIntegerField(blank=True, null=True)
# The new e-mail to use if validated
email_new = models.EmailField(_("new e-mail address"), blank=True, null=True)
# Keys
gpg_key = models.TextField(blank=True,
help_text=_("You can write down here your (ASCII) public key (gpg --export --armor keyid)"))
gpg_key_count = models.IntegerField(null=True, blank=True)
# SSH keys: cf. SshKey above
# Preferences - /!\ some are also in the user_preferences table
email_hide = models.BooleanField(default=False)
timezone = models.CharField(max_length=192, blank=True)
#theme = models.CharField(max_length=45, blank=True)
superuser_is_enabled = models.BooleanField(default=False)
# Inherit specialized models.Manager with convenience functions
objects = auth_models.UserManager()
@staticmethod
def query_active_users_raw(conn, fields):
"""
Return efficient query with all the users; used by LDIF export
"""
return conn.query("SELECT "
+ ",".join(fields)
+ " FROM auth_user JOIN svmain_extendeduser"
+ " ON auth_user.id = svmain_extendeduser.user_ptr_id"
+ " WHERE status = 'A'"
)
def get_full_name_display(self):
if self.user.get_full_name() != "":
return self.user.get_full_name()
else:
return self.user.username
def __unicode__(self):
return "Savane information on user %s" % (self.user.username)
class User(auth_models.AbstractBaseUser, auth_models.PermissionsMixin):
username = models.CharField(
_('username'),
max_length=75,
unique=True,
help_text=_(
'Required. 60 characters or less. Letters, digits, spaces and '
'@/./+/-/_ only.'),
validators=[
validators.RegexValidator(USERNAME_REGEX, USERNAME_INVALID_MESSAGE,
'invalid')
],
error_messages={
'unique': _('A user with that username already exists.')
})
email = models.EmailField(
_('email address'),
unique=True,
error_messages={
'unique': _('A user with that email address already exists.')
})
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.'))
_avatar = fields.ConfiguredImageField(
'avatar',
upload_to='users/images',
blank=True,
verbose_name=_('Profile picture'),
help_text=_('Please upload a picture in landscape format, at least '
'340x340 px. You can upload a .jpg, .png or .gif.'))
date_joined = models.DateTimeField(editable=False, default=timezone.now)
twitter_handle = models.CharField(
blank=True,
max_length=15,
verbose_name=_('Twitter name'),
)
facebook_handle = models.CharField(
blank=True,
max_length=50,
verbose_name=_('Facebook name'),
)
instagram_handle = models.CharField(
blank=True,
max_length=30,
verbose_name=_('Instagram name'),
)
website = models.URLField(blank=True,
verbose_name=_('Website'),
help_text=_(
'Please add either https:// or http:// '
'at the beginning of your URL.'))
get_notifications = models.BooleanField(
verbose_name=_("my own ideas and ideas that I'm watching"),
default=True)
objects = auth_models.UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username']
@property
def avatar(self):
if self._avatar:
return self._avatar
@property
def fallback_avatar(self):
number = self.pk % 3
return static('images/avatar-{0:02d}.svg'.format(number))
@property
def is_innovator(self):
return Idea.objects.filter(Q(creator=self)
| Q(co_workers=self)).count() > 0
def avatar_or_fallback_url(self):
if self._avatar:
return get_thumbnailer(self._avatar)['avatar'].url
else:
return self.fallback_avatar
def get_short_name(self):
return self.username
def get_full_name(self):
full_name = '%s <%s>' % (self.username, self.email)
return full_name.strip()
def signup(self, username, email, commit=True):
"""Update the fields required for sign-up."""
self.username = username
self.email = email
if commit:
self.save()
def get_absolute_url(self):
return reverse('profile', args=[str(self.username)])
class User(auth_models.AbstractBaseUser, auth_models.PermissionsMixin):
username = models.CharField(
_('username'),
max_length=60,
unique=True,
help_text=_(
'Required. 60 characters or fewer. Letters, digits, spaces and '
'@/./+/-/_ only.'),
validators=[
validators.RegexValidator(
USERNAME_REGEX, USERNAME_INVALID_MESSAGE, 'invalid')],
error_messages={
'unique': _('A user with that username already exists.'),
'used_as_email': _('This username is already used as an '
'e-mail address.')}
)
email = models.EmailField(
_('Email address'),
unique=True,
error_messages={
'unique': _('A user with that email address already exists.')}
)
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(
editable=False,
default=timezone.now
)
get_notifications = models.BooleanField(
verbose_name=_('Send me email notifications'),
default=True,
help_text=_(
'Designates whether you want to receive notifications. '
'Unselect if you do not want to receive notifications.')
)
get_newsletters = models.BooleanField(
verbose_name=_('I would like to receive further information'),
default=False,
help_text=_(
'Projects you are following can send you '
'additional information via email.')
)
bio = models.TextField(
blank=True,
max_length=255,
verbose_name=_('Biography'),
help_text=_(
'Tell us about yourself in 255 characters!')
)
twitter_handle = models.CharField(
blank=True,
max_length=15,
verbose_name=_('Twitter handle'),
)
facebook_handle = models.CharField(
blank=True,
max_length=50,
verbose_name=_('Facebook name'),
help_text=_(
'Your facebook name is the last part of the URL, '
'when you access your profile.')
)
homepage = models.URLField(
blank=True,
max_length=50,
verbose_name=_('Homepage'),
)
_avatar = ConfiguredImageField(
'avatar',
upload_to='users/images',
blank=True,
verbose_name=_('Avatar picture'),
)
language = models.CharField(
verbose_name=_('Your preferred language'),
choices=settings.LANGUAGES,
default=settings.DEFAULT_USER_LANGUAGE_CODE,
max_length=4,
help_text=_(
'Specify your preferred language for the user interface '
'and the notifications of the platform.'),
)
objects = auth_models.UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username']
def get_projects_follow_list(self, exclude_private_projects=False):
projects = Project.objects \
.filter(follow__creator=self,
follow__enabled=True,
is_draft=False)
if exclude_private_projects:
projects = projects.exclude(models.Q(access=Access.PRIVATE))
now = timezone.now()
sorted_active_projects = projects\
.annotate(project_start=models.Min('module__phase__start_date'))\
.annotate(project_end=models.Max('module__phase__end_date'))\
.filter(project_start__lte=now, project_end__gt=now)\
.order_by('project_end')
sorted_future_projects = projects\
.annotate(project_start=models.Min('module__phase__start_date'))\
.filter(models.Q(project_start__gt=now)
| models.Q(project_start=None))\
.order_by('project_start')
sorted_past_projects = projects\
.annotate(project_start=models.Min('module__phase__start_date'))\
.annotate(project_end=models.Max('module__phase__end_date'))\
.filter(project_end__lt=now)\
.order_by('project_start')
return sorted_active_projects, \
sorted_future_projects, \
sorted_past_projects
@cached_property
def organisations(self):
return self.organisation_set.all()
@cached_property
def avatar(self):
if self._avatar:
return self._avatar
@cached_property
def avatar_fallback(self):
number = self.pk % 4
return static('images/avatar-{0:02d}.svg'.format(number))
def get_short_name(self):
return self.username
def get_full_name(self):
full_name = '%s <%s>' % (self.username, self.email)
return full_name.strip()
def get_absolute_url(self):
return reverse('profile', args=[str(self.username)])
class AbstractUser(auth_models.AbstractBaseUser, auth_models.PermissionsMixin):
"""
An abstract base class implementing a fully featured User model with
admin-compliant permissions.
removed first_name, last_name field from default AbstractUser
phone_number and password are required. Other fields are optional.
"""
username_validator = UnicodeUsernameValidator()
username = models.CharField(
_('username'),
max_length=150,
unique=True,
help_text=
_('Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.'
),
validators=[username_validator],
error_messages={
'unique': _("A user with that username already exists."),
},
)
name = models.CharField(max_length=255)
email = models.EmailField(_('email address'))
phone_number = PhoneNumberField(_("Mobile Number"),
unique=True,
validators=[])
dob = models.DateField(_('Date of Birth'), null=True, blank=True)
is_mobile_verified = models.NullBooleanField()
is_email_verified = models.NullBooleanField()
gender = models.PositiveSmallIntegerField(choices=GENDER_CHOICES,
verbose_name='Gender',
null=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)
objects = auth_models.UserManager()
EMAIL_FIELD = 'email'
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['name', 'email', 'phone_number']
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
abstract = True
def get_full_name(self):
return self.name.strip()
def get_short_name(self):
return self.name.strip()
def clean(self):
super().clean()
self.email = self.__class__.objects.normalize_email(self.email)
def _migrate_alerts_to_user(self):
"""
Transfer any active alerts linked to a user's email address to the
newly registered user.
"""
ProductAlert = self.alerts.model
alerts = ProductAlert.objects.filter(email=self.email,
status=ProductAlert.ACTIVE)
alerts.update(user=self, key='', email='')
def save(self, *args, **kwargs):
super().save(*args, **kwargs)
# Migrate any "anonymous" product alerts to the registered user
# Ideally, this would be done via a post-save signal. But we can't
# use get_user_model to wire up signals to custom user models
# see Oscar ticket #1127, Django ticket #19218
self._migrate_alerts_to_user()
class User(auth_models.AbstractBaseUser, auth_models.PermissionsMixin):
username = models.CharField(
_('username'),
max_length=60,
unique=True,
help_text=_(
'Required. 60 characters or fewer. Letters, digits, spaces and '
'@/./+/-/_ only.'),
validators=[
validators.RegexValidator(
USERNAME_REGEX, USERNAME_INVALID_MESSAGE, 'invalid')],
error_messages={
'unique': _('A user with that username already exists.')}
)
email = models.EmailField(
_('Email address'),
unique=True,
error_messages={
'unique': _('A user with that email address already exists.')}
)
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(
editable=False,
default=timezone.now
)
get_notifications = models.BooleanField(
verbose_name=_('Send me email notifications'),
default=True,
help_text=_(
'Designates whether you want to receive notifications. '
'Unselect if you do not want to receive notifications.')
)
get_newsletters = models.BooleanField(
verbose_name=_('Send me newsletters'),
default=False,
help_text=_(
'Designates whether you want to receive newsletters. '
'Unselect if you do not want to receive newsletters.')
)
bio = models.TextField(
blank=True,
max_length=255,
verbose_name=_('Biography'),
help_text=_(
'Tell us about yourself in 255 characters!')
)
twitter_handle = models.CharField(
blank=True,
max_length=15,
verbose_name=_('Twitter handle'),
)
facebook_handle = models.CharField(
blank=True,
max_length=50,
verbose_name=_('Facebook name'),
help_text=_(
'Your facebook name is the last part of the URL, '
'when you access your profile.')
)
homepage = models.URLField(
blank=True,
max_length=50,
verbose_name=_('Homepage'),
)
_avatar = ConfiguredImageField(
'avatar',
upload_to='users/images',
blank=True,
verbose_name=_('Avatar picture'),
)
language = models.CharField(
verbose_name=_('Your preferred language'),
choices=settings.LANGUAGES,
default=settings.DEFAULT_USER_LANGUAGE_CODE,
max_length=4,
help_text=_(
'Specify your preferred language for the user interface '
'and the notifications of the platform.'),
)
objects = auth_models.UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username']
@cached_property
def organisations(self):
return self.organisation_set.all()
@cached_property
def avatar(self):
if self._avatar:
return self._avatar
def get_short_name(self):
return self.username
def get_full_name(self):
full_name = '%s <%s>' % (self.username, self.email)
return full_name.strip()
def get_absolute_url(self):
return reverse('profile', args=[str(self.username)])
class User(AbstractBaseUser, PermissionsMixin):
MALE = "M"
FEMALE = "F"
OTHER = "O"
GENDER_CHOICES = [
(None, None),
(MALE, "Mann"),
(FEMALE, "Kvinne"),
(OTHER, "Annet"),
]
username = models.CharField(max_length=60,
unique=True,
verbose_name="brukernavn")
email = models.EmailField(max_length=254,
unique=True,
null=True,
blank=True)
first_name = models.CharField(max_length=60,
null=True,
blank=True,
verbose_name="Fornavn")
last_name = models.CharField(max_length=150,
null=True,
blank=True,
verbose_name="Etternavn")
# department = models.ForeignKey('accounts.Department', on_delete=models.SET_NULL, null=True, blank=True, verbose_name="Avdeling", related_name="users")
# nickname = models.CharField(max_length=150, unique=True, null=True, blank=False, verbose_name="Kallenavn")
gender = models.CharField(max_length=1,
choices=GENDER_CHOICES,
default=None,
null=True,
blank=True,
verbose_name="Kjønn")
is_active = models.BooleanField(default=True)
phone_number = models.CharField(max_length=13,
default=None,
null=True,
blank=True,
verbose_name="Mobilnummer")
is_staff = models.BooleanField(default=False)
is_superuser = models.BooleanField(default=False)
date_joined = models.DateTimeField(default=timezone.now,
blank=True,
editable=False,
verbose_name="Opprettet")
objects = auth_models.UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = []
class Meta:
verbose_name = 'user'
verbose_name_plural = 'users'
ordering = ['username']
def __str__(self):
return f"{self.get_full_name() or self.username or self.email or self.id}"
def get_full_name(self):
if self.first_name and self.last_name:
return f"{self.first_name} {self.last_name}"
else:
return None
def get_username(self):
return self.username
def get_short_name(self):
return self.first_name
def serialize(self):
jayson = {}
jayson['id'] = self.id
# jayson['email'] = self.email
jayson['nickname'] = self.nickname
jayson['first_name'] = self.first_name
jayson['last_name'] = self.last_name
jayson['department'] = self.department
jayson['is_staff'] = self.is_staff
jayson['is_superuser'] = self.is_superuser
return jayson
class User(ActiveStateMixin, auth.AbstractBaseUser):
"""
A custom user model that stores the name in a more portable way. Also
stores information relating to project tracking.
"""
username = models.CharField(_('username'), max_length=30, unique=True,
help_text=_('Required. 30 characters or fewer. Letters, digits and '
'@/./+/-/_ only.'),
validators=[validators.RegexValidator(r'^[\w.@+-]+$',
_('Enter a valid username.'), 'invalid')])
full_name = models.CharField(_('full name'), max_length=255, blank=True)
short_name = models.CharField(_('preferred name'), max_length=50, blank=True)
email = models.EmailField(_('email address'), blank=True)
is_superuser = models.BooleanField(_('superuser status'), default=False,
help_text=_('Designates that this user has all permissions without '
'explicitly assigning them.'))
is_staff = models.BooleanField(_('staff status'), default=False,
help_text=_('Designates whether the user can log into this admin '
'site.'))
groups = models.ManyToManyField(auth.Group,
verbose_name=_('groups'), blank=True,
help_text=_('The groups this user belongs to. A user will get all '
'permissions granted to each of their groups.'),
related_name='custom_users', related_query_name='custom_user')
user_permissions = models.ManyToManyField(auth.Permission,
verbose_name=_('user permissions'), blank=True,
help_text=_('Specific permissions for this user.'),
related_name='custom_users', related_query_name='custom_user')
date_joined = models.DateTimeField(_('date joined'), default=timezone.now)
projects = models.ManyToManyField(Project, through=ProjectTracking,
verbose_name=_('tracked projects'), blank=True,
help_text=_('Projects this user is tracking'),
related_name='users', related_query_name='user')
objects = auth.UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def __str__(self):
return self.get_full_name()
def get_full_name(self):
return self.full_name
def get_short_name(self):
return self.short_name
def email_user(self, subject, message, from_email=None, **kwargs):
"""
Sends an email to this User.
"""
send_mail(subject, message, from_email, [self.email], **kwargs)
def get_projects(self, permission, followed=None):
"""
Returns a queryset of projects that the user has the specified
permissions on.
:param permission: Should be one of 'owner', 'member', or 'viewer'
depending on the desired permission desired.
"""
group_ids = self.groups.values_list('id', flat=True)
if permission == 'owner':
permission_filters = models.Q(owner_group_id__in=group_ids)
elif permission == 'member':
permission_filters = (models.Q(owner_group_id__in=group_ids) |
models.Q(member_group_id__in=group_ids))
elif permission == 'viewer':
permission_filters = (models.Q(owner_group_id__in=group_ids) |
models.Q(member_group_id__in=group_ids) |
models.Q(viewer_group_id__in=group_ids))
else:
raise ValueError('Permission {} is not valid. Should be one of '
'owner, member, or viewer'.format(permission))
if followed is None:
return Project.objects.filter(permission_filters)
elif followed is True:
return self.projects.filter(permission_filters)
else:
return (Project.objects.filter(permission_filters)
.exclude(id__in=self.projects.values_list('id', flat=True)))
def get_investigations(self, permission, followed=None):
"""
Returns a queryset of investigations that the user has the specified
permissions on.
:param permission: Should be one of 'owner', 'member', or 'viewer'
depending on the desired permission desired.
"""
project_ids = self.get_projects(permission,
followed).values_list('id', flat=True)
return Investigation.objects.filter(project_id__in=project_ids)
def get_milestones(self, permission, followed=None):
"""
Returns a queryset of milestones that the user has the specified
permissions on.
:param permission: Should be one of 'owner', 'member', or 'viewer'
depending on the desired permission desired.
"""
investigation_ids = self.get_investigations(permission,
followed).values_list('id', flat=True)
return Milestone.objects.filter(investigation_id__in=investigation_ids)
def get_tasks(self, permission, followed=None):
"""
Returns a queryset of milestones that the user has the specified
permissions on.
:param permission: Should be one of 'owner', 'member', or 'viewer'
depending on the desired permission desired.
"""
milestone_ids = self.get_milestones(permission,
followed).values_list('id', flat=True)
return Task.objects.filter(milestone_id__in=milestone_ids)
def get_group_permissions(self, obj=None):
"""
Returns a list of permission strings that this user has through their
groups. This method queries all available auth backends. If an object
is passed in, only permissions matching this object are returned.
"""
permissions = set()
for backend in auth.get_backends():
if hasattr(backend, "get_group_permissions"):
permissions.update(backend.get_group_permissions(self, obj))
return permissions
def get_all_permissions(self, obj=None):
return _user_get_all_permissions(self, obj)
def has_perm(self, perm, obj=None):
"""
Returns True if the user has the specified permission. This method
queries all available auth backends, but returns immediately if any
backend returns True. Thus, a user who has permission from a single
auth backend is assumed to have permission in general. If an object is
provided, permissions for this specific object are checked.
"""
# Active superusers have all permissions.
if self.is_active and self.is_superuser:
return True
# Otherwise we need to check the backends.
return _user_has_perm(self, perm, obj)
def has_perms(self, perm_list, obj=None):
"""
Returns True if the user has each of the specified permissions. If
object is passed, it checks if the user has all required perms for this
object.
"""
for perm in perm_list:
if not self.has_perm(perm, obj):
return False
return True
def has_module_perms(self, app_label):
"""
Returns True if the user has any permissions in the given app label.
Uses pretty much the same logic as has_perm, above.
"""
# Active superusers have all permissions.
if self.is_active and self.is_superuser:
return True
return _user_has_module_perms(self, app_label)
class User(auth_models.AbstractBaseUser, auth_models.PermissionsMixin):
username = models.CharField(_('username'),
max_length=60,
unique=True,
help_text=USERNAME_HELP,
validators=[USERNAME_VALIDATOR],
error_messages={
'unique': _(USERNAME_NOT_UNIQUE),
})
email = models.EmailField(_('email address'),
unique=True,
error_messages={
'unique': EMAIL_NOT_UNIQUE,
})
is_staff = models.BooleanField(_('staff status'),
default=False,
help_text=IS_STAFF_HELP)
is_active = models.BooleanField(_('active'),
default=True,
help_text=IS_ACTIVE_HELP)
date_joined = models.DateTimeField(editable=False, default=timezone.now)
get_notifications = models.BooleanField(
verbose_name=_('Send me email notifications'),
default=True,
help_text=GET_NOTIFICATIONS_HELP)
objects = auth_models.UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username']
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
def get_absolute_url(self):
return reverse('profile', kwargs={'slug': str(self.username)})
@property
def organisations(self):
return self.organisation_set.all()
def get_full_name(self):
full_name = '%s <%s>' % (self.username, self.email)
return full_name.strip()
def get_short_name(self):
"""Return the short name for the user."""
return self.username
def signup(self, username, email, commit=True):
"""Update the fields required for sign-up."""
self.username = username
self.email = email
if commit:
self.save()
