def create_registered_client(self, name, email, password):
client = Client()
manager = UserManager()
manager.model = User
user = manager.create_user(name, email, password)
user.save()
client.login(username=name, password=password)
return client
def new_password(request):
"""
This function sends new password to the given email address.
Returns:
200 if successful
400 if email address is not confirmed
404 if email address is not found
"""
if(request.method == "POST"):
try:
request_json = json.loads(request.body)
except ValueError:
return HttpResponseBadRequest("The post request was not valid JSON")
except IndexError:
return HttpResponseBadRequest("POST data was empty so no "
"new_password value could be "
"retrieved from it")
email = request_json['email']
current_user = User.objects.filter(email=email)[0]
um = UserManager()
password = um.make_random_password()
current_site = Site.objects.get_current()
context = {
"current_user": current_user,
"password": password,
"current_site": current_site
}
subject = render_to_string(
"email_templates/new_password_email_subject.txt", context)
# remove superfluous line breaks
subject = "".join(subject.splitlines())
message = render_to_string(
"email_templates/new_password_email_content.txt", context)
try:
send_mail(subject,
message,
'*****@*****.**',
[current_user.email])
current_user.set_password(password)
current_user.save()
return HttpResponse(u"New password was sent")
except BadHeaderError:
return HttpResponseBadRequest(u'Invalid header found.')
return HttpResponseBadRequest("This URL only accepts POST requests")
def retrieve_access(cls, username_or_email): profiles = UserProfile.objects.filter(Q(user__username=username_or_email) | Q(user__email=username_or_email)).exclude(is_from_oauth=True) for user in [profile.user for profile in profiles]: um = UserManager() new_password = um.make_random_password(6, user.username) user.set_password(new_password) user.save() UserNotification.getNotification().notify_password_change(user, new_password) return len(profiles) > 0
def resend_password(user):
um = UserManager()
password=um.make_random_password(length=10,allowed_chars='abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ')
user.set_password(str(password))
user.save()
subject='Tu nuevo password'
message='Hola '+user.username+', Tu nuevo password es '+password
recipient=[user.email]
send_mail(subject, message, '*****@*****.**', recipient, fail_silently=False)
print message
def setUp(self):
self.client = client.Client()
manager = UserManager()
manager.model = get_user_model()
self.user = manager.create_user("mm285", "*****@*****.**", "123456")
self.user.is_active = False
self.user.save()
self.user_auth_token = UserAuthToken(user=self.user)
self.user_auth_token.save()
def create_authorised_client(self, name, email, password):
client = Client()
manager = UserManager()
manager.model = User
user = manager.create_user(name, email, password)
user.user_permissions.add(Permission.objects.get(codename="send_mails_to"))
user.user_permissions.add(Permission.objects.get(codename="add_privately"))
self.assert_(user.has_perm('participantdatabase.send_mails_to'))
self.assert_(user.has_perm('participantdatabase.add_privately'))
user.save()
client.login(username=name, password=password)
return client
def setUp(self):
self.client = Client()
# when creating a System and a Local Computer
self.system = System.objects.create(name="a_name")
self.local_computer = LocalComputer.objects.create(name="local_computer", secret_uuid="my_uuid")
# and a user
um = UserManager()
um.model = User
self.user = um.create_user("bob", "*****@*****.**", "hello")
self.client = Client()
self.client.login(username="******", password="******")
def setUp(self):
area= Tree.objects.create(name='广州',tree_type=Tree.get_type(0))
car=Tree.objects.create(name='君威2014款',tree_type=Tree.get_type(1))
service=Tree.objects.create(name='玻璃贴膜',tree_type=Tree.get_type(2))
brand=Tree.objects.create(name='3M',tree_type=Tree.get_type(3))
foil_type= Tree.objects.create(name='整车',tree_type=Tree.get_type(6))
foil_model_front=Tree.objects.create(name='前挡类型',tree_type=Tree.get_type(7))
supplier=Supplier.objects.create(
name='s1',
area=area,
address='address1',
coordinate_x=120.01234,
coordinate_y=30.1234,
#photo=# ImageField(blank=True,null=True,upload_to='photos/suppliers')
phone='1234567',
time_open=time(10,0,0),
time_close=time(19,0,0),
description='description of s1',
owner=UserManager.create_user('phiree', email=None, password=None)
)
service=Service.objects.create(supplier=supplier,service_type=service,car=car)
def create_user_profile(realm, email, password, active, bot_type, full_name,
short_name, bot_owner, is_mirror_dummy, tos_version,
timezone, tutorial_status=UserProfile.TUTORIAL_WAITING,
enter_sends=False):
# type: (Realm, Text, Optional[Text], bool, Optional[int], Text, Text, Optional[UserProfile], bool, Text, Optional[Text], Optional[Text], bool) -> UserProfile
now = timezone_now()
email = UserManager.normalize_email(email)
user_profile = UserProfile(email=email, is_staff=False, is_active=active,
full_name=full_name, short_name=short_name,
last_login=now, date_joined=now, realm=realm,
pointer=-1, is_bot=bool(bot_type), bot_type=bot_type,
bot_owner=bot_owner, is_mirror_dummy=is_mirror_dummy,
tos_version=tos_version, timezone=timezone,
tutorial_status=tutorial_status,
enter_sends=enter_sends,
onboarding_steps=ujson.dumps([]),
default_language=realm.default_language)
if bot_type or not active:
password = None
user_profile.set_password(password)
user_profile.api_key = random_api_key()
return user_profile
def create_user(self, username,
vk_user_id=None, fb_user_id=None,
gender=None, birth_date=None,
email=None, password=None, **extra_fields):
"""
Creates and saves a User with the given username, email and password.
"""
now = timezone.now()
if not username:
raise ValueError('The given username must be set')
email = UserManager.normalize_email(email)
user = self.model(username=username,
vk_user_id=vk_user_id,
fb_user_id=fb_user_id,
gender=gender,
birth_date=birth_date,
email=email,
is_staff=False, is_active=True, is_superuser=False,
last_login=now, date_joined=now, **extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
def create_user_profile(realm: Realm, email: str, password: Optional[str],
active: bool, bot_type: Optional[int], full_name: str,
short_name: str, bot_owner: Optional[UserProfile],
is_mirror_dummy: bool, tos_version: Optional[str],
timezone: Optional[str],
tutorial_status: Optional[str] = UserProfile.TUTORIAL_WAITING,
enter_sends: bool = False) -> UserProfile:
now = timezone_now()
email = UserManager.normalize_email(email)
user_profile = UserProfile(email=email, is_staff=False, is_active=active,
full_name=full_name, short_name=short_name,
last_login=now, date_joined=now, realm=realm,
pointer=-1, is_bot=bool(bot_type), bot_type=bot_type,
bot_owner=bot_owner, is_mirror_dummy=is_mirror_dummy,
tos_version=tos_version, timezone=timezone,
tutorial_status=tutorial_status,
enter_sends=enter_sends,
onboarding_steps=ujson.dumps([]),
default_language=realm.default_language,
twenty_four_hour_time=realm.default_twenty_four_hour_time,
delivery_email=email)
if bot_type or not active:
password = None
user_profile.set_password(password)
user_profile.api_key = generate_api_key()
return user_profile
def create_user_profile(realm, email, password, active, bot_type, full_name,
short_name, bot_owner, is_mirror_dummy, tos_version):
# type: (Realm, text_type, text_type, bool, Optional[int], text_type, text_type, Optional[UserProfile], bool, Optional[text_type]) -> UserProfile
now = timezone.now()
email = UserManager.normalize_email(email)
enable_stream_desktop_notifications = (realm.domain != 'zulip.com')
user_profile = UserProfile(email=email, is_staff=False, is_active=active,
full_name=full_name, short_name=short_name,
last_login=now, date_joined=now, realm=realm,
pointer=-1, is_bot=bool(bot_type), bot_type=bot_type,
is_mirror_dummy=is_mirror_dummy,
tos_version=tos_version,
enable_stream_desktop_notifications=enable_stream_desktop_notifications,
onboarding_steps=ujson.dumps([]),
default_language=realm.default_language)
if bot_owner is not None:
# `user_profile.bot_owner = bot_owner` doesn't work on python 3.4
user_profile.bot_owner_id = bot_owner.id
if bot_type or not active:
password = None
user_profile.set_password(password)
user_profile.api_key = random_api_key()
return user_profile
def create_user_profile(realm: Realm, email: str, password: Optional[str],
active: bool, bot_type: Optional[int], full_name: str,
short_name: str, bot_owner: Optional[UserProfile],
is_mirror_dummy: bool, tos_version: Optional[str],
timezone: Optional[str],
tutorial_status: Optional[str] = UserProfile.TUTORIAL_WAITING,
enter_sends: bool = False) -> UserProfile:
now = timezone_now()
email = UserManager.normalize_email(email)
user_profile = UserProfile(is_staff=False, is_active=active,
full_name=full_name, short_name=short_name,
last_login=now, date_joined=now, realm=realm,
pointer=-1, is_bot=bool(bot_type), bot_type=bot_type,
bot_owner=bot_owner, is_mirror_dummy=is_mirror_dummy,
tos_version=tos_version, timezone=timezone,
tutorial_status=tutorial_status,
enter_sends=enter_sends,
onboarding_steps=ujson.dumps([]),
default_language=realm.default_language,
twenty_four_hour_time=realm.default_twenty_four_hour_time,
delivery_email=email)
if bot_type or not active:
password = None
if realm.email_address_visibility == Realm.EMAIL_ADDRESS_VISIBILITY_EVERYONE:
# If emails are visible to everyone, we can set this here and save a DB query
user_profile.email = get_display_email_address(user_profile, realm)
user_profile.set_password(password)
user_profile.api_key = generate_api_key()
return user_profile
def create_user(self, email, password=None, **extra_fields):
now = timezone.now()
email = BaseUserManager.normalize_email(email)
user = self.model(email=email, is_staff=False, is_active=True, is_superuser=False, last_login=now,
date_joined=now, **extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
def create_superuser(self, username, email, password, **extra_fields):
with transaction.atomic():
su = DJ_UserManager.create_superuser(self, username, email, password, **extra_fields)
su.profile.new_notify = False
su.profile.save()
su.groups.add(Group.objects.get(pk=GROUP_ADMIN))
su.save()
return su
def create_user(self, email, password=None, is_staff=False, is_active=True, **extra_fields):
# Создает пользователся с данными: имя, email, пароль
email = UserManager.normalize_email(email)
user = self.model(email=email, is_active=is_active, is_staff=is_staff, **extra_fields)
if password:
user.set_password(password)
user.save()
return user
def create_user(self, username, email, password=None, **kwargs):
now = timezone.now()
if not email:
raise ValueError('The given email address must be set')
email = UserManager.normalize_email(email)
user = self.model(username=username, email=email, date_joined=now, is_superuser=False, is_staff=False, **kwargs)
user.set_password(password)
user.save(using=self._db)
return user
def create_user(self, email=None, password=None, **extra_fields):
now = timezone.now()
if not email:
raise ValueError('The given email must be set')
email = UserManager.normalize_email(email)
user = self.model(email=email, is_staff=False, is_active=True, is_superuser=False, last_login=now, **extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
def create_user(self, email=None, password=None, **extra_fields):
now = datetime.utcnow()
if not email:
raise ValueError('Email address must be given')
email = UserManager.normalize_email(email)
user = self.model(email=email, is_staff=False, is_active=False, is_superuser=False, last_login=now, reg_code=self.create_reg_code(), **extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
def create_user(self, username, email, password=None): #,**extra_fields):
user = self.model()
if not email:
raise ValueError('Users must have an email address.')
email = UserManager.normalize_email(email)
user = self.model(username=username, email=email)
#user = self.model(username=username, email=email, is_staff=False, is_active=True, is_superuser=False)
user.set_password(password)
user.save(using=self._db)
return user
def normalize_email(value):
"""
Normalize an email address by lowercasing domain part.
Return None if the given value doesn't appear to be an email address.
"""
if email_re.search(smart_unicode(value)):
return UserManager.normalize_email(value)
return None
def create_user(cls, username, email, password=None, **extra_fields):
now = timezone.now()
if not username:
raise ValueError('The given username must be set')
email = UserManager.normalize_email(email)
user = CustomEmployer(username=username, email=email, is_staff=False, is_active=True, is_superuser=False,
last_login=now, date_joined=now, **extra_fields)
user.set_password(password)
user.save()
return user
def create_user(self, email, password=None, **extra_fields):
now = timezone.now()
if not email:
raise ValueError('Users must have an email address')
user = self.model(
email=UserManager.normalize_email(email),
is_staff=False, is_active=True, is_superuser=False,
last_login=now, date_joined=now, **extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
def create_user(self, email, password=None, **extra_fields):
now = timezone.now()
if not email:
raise ValueError(u'رایانامه باید تعیین شود')
email = UserManager.normalize_email(email)
user = self.model(email=email, is_active=True, is_admin=False,
last_login=now, date_joined=now, **extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
def create_user(self, email, password=None):
"""
Creates and saves a User with the given email
"""
if not email:
raise ValueError('Users must have an email address')
user = self.model(
email=UserManager.normalize_email(email),
)
user.set_password(password)
user.save(using=self._db)
return user
def post(self, request, *args, **kwargs):
data = json.loads(request.body)
assert 'username' in data
assert 'password' in data
assert 'email' in data
try:
User.objects.get(username=data['username'])
except User.DoesNotExist:
pass
else:
return HttpResponse(json.dumps({"status": "error", "msg": "duplicated"}))
UserManager.create_user(
username=data['username'],
email=data['email'],
password=['password']
)
AdvancedPerInfo.objects.create(
user=user,
default_chunksize=MIN_CHUNK_SIZE,
default_path=['home', user.username]
)
return HttpResponse(json.dumps({"status": "OK"}))
def edytuj_rodzica(request,klasa_id,rod_id,klucz,r_id):
if not request.user.is_authenticated():return HttpResponseRedirect('/')
#model = slownik[klucz]
try:
manipulator = User.ChangeManipulator(rod_id)
except User.DoesNotExist:
raise Http404
rekord = manipulator.original_object
x = UserManager()
pas = x.make_random_password()
from django.contrib.auth.models import get_hexdigest
#passs = get_hexdigest('sha1', '', pas)
if request.POST:
new_data = request.POST.copy()
if new_data['password']=='':new_data['password']=rekord.password
else:
u = User()
new_data['password'] = u.set_password(new_data['password'])
new_data['groups']=4
errors = manipulator.get_validation_errors(new_data)
if not errors:
manipulator.do_html2python(new_data)
manipulator.save(new_data)
return HttpResponseRedirect('/'+klasa_id+ '/Lista uczniow/')
else:
errors = {}
new_data = rekord.__dict__
form = oldforms.FormWrapper(manipulator, new_data, errors)
u = Uczniowie_tmp.objects.get(id=r_id)
full_name = u.get_full_name()
return render_to_response('forms_wych.html',
{klucz: form,'rekord': rekord,'tytul': 'Edycja','header':'Edycja ucznia','del':'yes','rod_id':rod_id,'dane_ucznia':full_name},
context_instance=RequestContext(request))
def create_user(self, email, password=None, **extra_fields):
"""
Creates and saves a User with the given username, email and password.
"""
now = timezone.now()
if not email:
raise ValueError('The given email must be set')
email = UserManager.normalize_email(email)
user = self.model(email=email, is_staff=False, is_superuser=False,
last_login=now, date_joined=now, **extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
def create_user(self, *args, **kwargs):
"""
"""
self.model = DragonUser
user = UserManager.create_user(self, *args, **kwargs)
if user.user_type == 'admin': return user
try:
profileType = globals()[capitalize(self.user_type) + 'Profile']
except KeyError:
raise KeyError('No profile type for user of type: %s' % user.user_type)
else:
myProfile = profileType.objects.filter(user_id=self.id)
if not len(myProfile): myProfile.create(user=self.id)
return user
def create_user(self, usuario, password, nombre,apellidos,email=""):
"""
Creates and saves user with the given username and password.
"""
# if not email:
# raise ValueError('Favor de proporcionar un correo valido')
if not usuario:
raise ValueError('Favor de proporcionar un usuario valido')
usuario = self.model(
email=UserManager.normalize_email(email),nombre=nombre,apellidos=apellidos,usuario=usuario
)
usuario.set_password(password)
usuario.save(using=self._db)
return usuario
class MyUser(AbstractBaseUser, PermissionsMixin):
"""
An abstract base class implementing a fully featured User model with
admin-compliant permissions.
Username, password and email are required. Other fields are optional.
"""
username = models.CharField(
_('username'),
max_length=100,
unique=True,
help_text=_('Tələb olunur. 75 simvol və ya az. Hərflər, Rəqəmlər və '
'@/./+/-/_ simvollar.'),
validators=[
validators.RegexValidator(r'^[\w.@+-]+$',
_('Düzgün istifadəçi adı daxil edin.'),
'yanlışdır')
])
first_name = models.CharField(_('first name'), max_length=255, blank=True)
last_name = models.CharField(_('last name'), max_length=255, blank=True)
email = models.EmailField(_('email address'), max_length=255)
profile_picture = models.ImageField(
upload_to=get_user_profile_photo_file_name, null=True, blank=True)
gender = models.IntegerField(choices=GENDER,
verbose_name="cinsi",
null=True,
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)
"""
Important non-field stuff
"""
objects = UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
class Meta:
verbose_name = 'İstifadəçi'
verbose_name_plural = 'İstifadəçilər'
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
def get_avatar(self):
if self.profile_picture:
try:
return "https://graph.facebook.com/%s/picture?type=large" % self.social_auth.get(
provider='facebook').uid
except:
return "https://graph.facebook.com/%s/picture?type=large" % '100002461198950'
else:
return "https://graph.facebook.com/%s/picture?type=large" % '100002461198950'
class User(AbstractBaseUser, PermissionsMixin):
username = models.CharField(
'昵称', max_length=30, unique=True, help_text='昵称长度4-20个字符，支持中英文、数字、-、_',
validators=[
validators.RegexValidator('^[a-zA-Z0-9-_\u4e00-\u9fa5]+$',
'昵称长度4-20个字符，支持中英文、数字、-、_', 'invalid')
])
email = models.EmailField('邮箱', default=None, unique=True, null=True, blank=True)
password = models.CharField('密码', blank=True, null=True, max_length=128)
is_password_set = models.BooleanField('是否设置密码', default=True)
is_username_set = models.BooleanField('是否设置昵称', default=True)
date_joined = models.DateTimeField('注册时间', default=timezone.now)
is_staff = models.BooleanField('是否是职员', default=False)
mobile = models.CharField('手机号', max_length=100, default=None, unique=True, null=True)
province = models.CharField('省份', max_length=100, null=True, blank=True, db_index=True)
city = models.CharField('城市', max_length=100, null=True, blank=True, db_index=True)
district = models.CharField('地区', max_length=50, null=True, blank=True)
street = models.CharField('详细地址', max_length=100, null=True, blank=True)
GENDER = (
(0, '保密'),
(1, '男'),
(2, '女'),
)
CAREER = (
('5', '房地产'),
('10', '国有企业'),
('2', '教科文'),
('3', '金融'),
('4', '商贸'),
('9', '事业单位'),
('1', '政府部门'),
('6', '制造业'),
('7', '自由职业'),
('8', '其他'),
)
gender = models.SmallIntegerField('性别', null=True, blank=True, choices=GENDER, default=0)
description = models.TextField('简介', null=True, blank=True)
birthday = models.DateField('生日', null=True, blank=True)
career = models.CharField(
'职业', choices=CAREER, max_length=20, null=True, blank=True)
qq = models.CharField(max_length=20, default=None, null=True, blank=True)
we_chat = models.CharField(
'微信', max_length=200, default=None, null=True, blank=True)
we_bo = models.CharField(
'微博', max_length=200, default=None, null=True, blank=True)
modified_at = models.DateTimeField('修改时间', auto_now = True)
VERIFIED_STATUS = (
(-1, '未提交'),
(0, '审核中'),
(1, '已认证'),
(2, '审核失败'),
)
verified_status = models.SmallIntegerField('认证状态', choices=VERIFIED_STATUS, default=-1)
verified_reason = models.CharField('认证说明', max_length=200, null=True, blank=True)
is_system = models.BooleanField('是否系统用户', default=False)
objects = UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
class Meta:
verbose_name = '用户'
verbose_name_plural = verbose_name
app_label = 'accounts'
class CustomUser(AbstractBaseUser, PermissionsMixin):
"""
A custom user class that basically mirrors Django's `AbstractUser` class
and doesn'0t 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=False)
short_name = models.CharField(_('short name'), max_length=30, blank=True)
choices = (('Male', 'Male'), ('Female', 'Female'))
sex = models.CharField(_('sex'),
max_length=30,
blank=False,
choices=choices)
email = models.EmailField(_('email address'), max_length=254, unique=True)
phone_number = models.CharField(_('phone number'),
max_length=20,
validators=[
validators.RegexValidator(
re.compile('^[0-9]+$'),
_('Only numbers are allowed.'),
'invalid')
])
user_choices = (('Driver', 'Driver'), ('Passenger', 'Passenger'))
user_type = models.CharField(_('user type'),
max_length=30,
blank=False,
choices=user_choices)
address = models.TextField(_('location'), max_length=400, blank=False)
is_staff = models.BooleanField(
_('staff status'),
default=False,
help_text=_('Designates whether the user can log into this admin '
'site.'))
is_verified = models.BooleanField(
_('user verified'),
default=False,
help_text=_('Designates whether the user is a vershified user'))
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 = UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def __unicode__(self):
return self.username
def get_absolute_url(self):
return "/profile/%s" % 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_sex(self):
return self.sex
def email_user(self, subject, message, from_email=None):
"""
Sends an email to this User.
"""
send_mail(subject, message, from_email, [self.email])
def get_no_messages(self):
number = Message.objects.filter(recipient=self, read=False)
if number.count() > 0:
return number.count()
else:
return None
def get_messages(self):
msg = Message.objects.filter(recipient=self,
read=False).order_by('date').reverse()
return msg
def get_messages_all(self):
msg = Message.objects.filter(recipient=self).order_by('date').reverse()
return msg
def get_notifications(self):
return self.notifications.unread()
def get_no_notifs(self):
return self.notifications.unread().count()
def is_follows(self, user_1):
foll = Follow.objects.filter(follower=self, followee=user_1)
if foll.exists():
return True
else:
return False
def get_no_followers(self):
num = Follow.objects.filter(followee=self).count()
return num
def get_no_following(self):
num = Follow.objects.filter(follower=self).count()
return num
def get_following(self):
num = Follow.objects.filter(follower=self).values_list('followee')
result = []
for follower in num:
user = CustomUser.objects.get(pk=follower[0])
result.append(user)
return result
def get_profile(self):
profile = Profile.objects.get(user=self)
return profile
def no_of_rides_shared(self):
return self.vehiclesharing_set.filter(user=self, ended=True).count()
def no_of_request_completed(self):
return self.request_set.filter(status='approved', user=self).count()
def get_no_broadcast(self):
return Broadcast.objects.filter(user=self).count()
def get_broadcast(self):
all_broad = Broadcast.objects.filter(user=self)[0:10]
return all_broad
class LilyUser(TenantMixin, PermissionsMixin, AbstractBaseUser):
"""
A custom user class implementing a fully featured User model with
admin-compliant permissions.
Password and email are required. Other fields are optional.
"""
first_name = models.CharField(_('first name'), max_length=255)
last_name = models.CharField(_('last name'), max_length=255)
picture = models.ImageField(upload_to=get_lilyuser_picture_upload_path,
verbose_name=_('picture'),
blank=True)
email = models.EmailField(_('email address'), max_length=255, unique=True)
position = models.CharField(_('position'), max_length=255, 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)
teams = models.ManyToManyField(
Team,
verbose_name=_('Lily teams'),
blank=True,
related_name='user_set',
related_query_name='user',
)
phone_number = models.CharField(_('phone number'),
max_length=40,
blank=True)
internal_number = models.PositiveSmallIntegerField(_('internal number'),
blank=True,
null=True)
social_media = models.ManyToManyField(
SocialMedia, blank=True, verbose_name=_('list of social media'))
language = models.CharField(_('language'),
max_length=3,
choices=settings.LANGUAGES,
default='en')
timezone = TimeZoneField(default='Europe/Amsterdam')
primary_email_account = models.ForeignKey('email.EmailAccount',
blank=True,
null=True,
on_delete=models.SET_NULL)
webhooks = models.ManyToManyField(Webhook, blank=True)
info = models.ForeignKey(UserInfo,
blank=True,
null=True,
on_delete=models.SET_NULL)
objects = LilyUserManager()
all_objects = UserManager()
EMAIL_TEMPLATE_PARAMETERS = [
'first_name', 'last_name', 'full_name', 'position', 'twitter',
'linkedin', 'phone_number', 'current_email_address', 'user_team',
'profile_picture'
]
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = [
'first_name',
'last_name',
]
def save(self, *args, **kwargs):
self.email = self.email.lower()
super(LilyUser, self).save(*args, **kwargs)
def delete(self, using=None, hard=False):
"""
Soft delete instance by flagging is_active as False.
Arguments:
using (str): which db to use
hard (boolean): If True, permanent removal from db
"""
if hard:
super(LilyUser, self).delete(using=using)
else:
self.is_active = False
self.save()
@property
def full_name(self):
return self.get_full_name()
def get_full_name(self):
"""
Return full name of this user without unnecessary white space.
"""
return u' '.join([self.first_name, self.last_name]).strip()
def get_short_name(self):
"""
Returns the short name for the user.
"""
return self.first_name
def email_user(self, subject, message, from_email=None):
"""
Sends an email to this User.
"""
send_mail(subject, message, from_email, [self.email])
@property
def profile_picture(self):
if self.picture:
return self.picture.url
else:
gravatar_hash = self.email.lower().encode('utf-8',
errors='replace')
gravatar_hash = hashlib.md5(gravatar_hash).hexdigest()
# Try to get the Gravatar or show a default image if not available.
gravatar_url = 'https://secure.gravatar.com/avatar/' + gravatar_hash + '?'
gravatar_url += urllib.quote(
urllib.urlencode({
'd': 'mm',
's': str(200)
}))
return gravatar_url
@property
def twitter(self):
try:
twitter = self.social_media.filter(name='twitter').first()
except SocialMedia.DoesNotExist:
pass
else:
return twitter.username
@property
def linkedin(self):
try:
linkedin = self.social_media.filter(name='linkedin').first()
except SocialMedia.DoesNotExist:
pass
else:
return linkedin.profile_url
@property
def user_team(self):
user_team = self.teams.first()
if not user_team:
return ''
return user_team
@property
def display_email_warning(self):
return self.email_accounts_owned.filter(is_authorized=False,
is_deleted=False).exists()
@property
def user_hash(self):
return hmac.new(settings.INTERCOM_HMAC_SECRET,
str(self.pk),
digestmod=hashlib.sha256).hexdigest()
@property
def is_admin(self):
return self.groups.filter(
name='account_admin').exists() or self.is_superuser
def __unicode__(self):
return self.full_name
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
ordering = ['first_name', 'last_name']
permissions = (('send_invitation',
_('Can send invitations to invite new users')), )
unique_together = ('tenant', 'internal_number')
class User(AbstractBaseUser, PermissionsMixin):
username = models.CharField(
_('username'),
max_length=30,
unique=True,
help_text=
_('Required. 30 characters or fewer. Letters, digits and @/./+/-/_ only.'
),
validators=[ASCIIUsernameValidator()],
error_messages={
'unique': _("A user with that username already exists."),
},
)
first_name = models.CharField(_('first name'), max_length=100, blank=True)
last_name = models.CharField(_('last name'), max_length=100, blank=True)
email = models.EmailField(_('email address'), blank=True, max_length=100)
name_verified = models.BooleanField(
_('Name verified'),
default=False,
help_text=_('Indicates that this user\'s name has been verified '
'as being associated with the individual able to sign '
'in to this account.'),
)
is_active = models.BooleanField(
pgettext_lazy("User status", "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 = UserManager()
is_staff = models.BooleanField(
_('staff status'),
default=False,
help_text=_(
'Designates whether the user can log into this admin site.'),
)
institutional_id = models.CharField(max_length=100,
verbose_name=_('Institutional ID'),
blank=True,
null=True,
unique=True,
db_index=True)
institutional_id_verified = models.BooleanField(
_('Institutional ID verified'),
default=False,
help_text=_(
'Indicates that this user\'s institutional ID has been verified '
'as being associated with the individual able to log '
'in to this account.'),
)
status = models.CharField(max_length=50,
choices=USER_STATUS_CHOICES,
verbose_name=_('User status'),
null=True)
sign_in_key = models.CharField(
max_length=50,
help_text=_("The sign in token sent out in email."),
null=True,
unique=True,
db_index=True,
blank=True,
# Translators: the sign in token of the user.
verbose_name=_('Sign in key'))
key_time = models.DateTimeField(
default=None,
null=True,
blank=True,
help_text=_("The time stamp of the sign in token."),
# Translators: the time when the token is sent out.
verbose_name=_('Key time'))
editor_mode = models.CharField(
max_length=20,
help_text=_("Which key bindings you prefer when editing "
"larger amounts of text or code. "
"(If you do not understand what this means, "
"leave it as 'Default'.)"),
choices=(
("default", _("Default")),
("sublime", "Sublime text"),
("emacs", "Emacs"),
("vim", "Vim"),
),
default="default",
# Translators: the text editor used by participants
verbose_name=_("Editor mode"))
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def get_full_name(self, allow_blank=True, force_verbose_blank=False):
if (not allow_blank and (not self.first_name or not self.last_name)):
return None
def verbose_blank(s):
if force_verbose_blank:
if not s:
return _("(blank)")
else:
return s
return s
def default_fullname(first_name, last_name):
"""
Returns the first_name plus the last_name, with a space in
between.
"""
return '%s %s' % (verbose_blank(first_name),
verbose_blank(last_name))
from accounts.utils import relate_user_method_settings
format_method = relate_user_method_settings.custom_full_name_method
if format_method is None:
format_method = default_fullname
try:
full_name = format_method(verbose_blank(self.first_name),
verbose_blank(self.last_name))
except Exception:
full_name = default_fullname(verbose_blank(self.first_name),
verbose_blank(self.last_name))
return full_name.strip()
def get_masked_profile(self):
"""
Returns the masked user profile.
"""
def default_mask_method(user):
return "%s%s" % (_("User"), str(user.pk))
from django.conf import settings
mask_method = getattr(settings, "RELATE_USER_PROFILE_MASK_METHOD",
default_mask_method)
return str(mask_method(self)).strip()
def get_short_name(self):
"Returns the short name for the user."
return self.first_name
def get_email_appellation(self):
"Return the appellation of the receiver in email."
from accounts.utils import relate_user_method_settings
priority_list = (
relate_user_method_settings.email_appellation_priority_list)
for attr in priority_list:
if attr == "full_name":
appellation = self.get_full_name(allow_blank=False)
else:
appellation = getattr(self, attr)
if not appellation:
continue
return appellation
return _("user")
def clean(self):
super(User, self).clean()
# email can be None in Django admin when create new user
if self.email is not None:
self.email = self.email.strip()
if self.email:
qset = self.__class__.objects.filter(email__iexact=self.email)
if self.pk is not None:
# In case editing an existing user object
qset = qset.exclude(pk=self.pk)
if qset.exists():
from django.core.exceptions import ValidationError
raise ValidationError(
{"email": _("That email address is already in use.")})
def save(self, *args, **kwargs):
update_fields = kwargs.get("update_fields")
# This is for backward compatibility.
# Because user instances are frequently updated when auth_login,
# reset_password. Without this, no user will be able to login.
if ((update_fields is not None and "email" in update_fields)
or self.pk is None):
self.clean()
if self.institutional_id is not None:
self.institutional_id = self.institutional_id.strip()
# works around https://code.djangoproject.com/ticket/4136#comment:33
self.institutional_id = self.institutional_id or None
super(User, self).save(*args, **kwargs)
class User(
LoggableMixin,
UuidMixin,
DescribableMixin,
AbstractBaseUser,
UserDetailsMixin,
PermissionsMixin,
):
username = models.CharField(
_('username'),
max_length=128,
unique=True,
help_text=_('Required. 128 characters or fewer. Letters, numbers and '
'@/./+/-/_ characters'),
validators=[
validators.RegexValidator(re.compile(r'^[\w.@+-]+$'),
_('Enter a valid username.'), 'invalid')
],
)
# Civil number is nullable on purpose, otherwise
# it wouldn't be possible to put a unique constraint on it
civil_number = models.CharField(
_('civil number'),
max_length=50,
unique=True,
blank=True,
null=True,
default=None,
)
email = models.EmailField(_('email address'), max_length=75, 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.'),
)
is_support = models.BooleanField(
_('support status'),
default=False,
help_text=_('Designates whether the user is a global support user.'),
)
date_joined = models.DateTimeField(_('date joined'),
default=django_timezone.now)
registration_method = models.CharField(
_('registration method'),
max_length=50,
default='default',
blank=True,
help_text=_('Indicates what registration method were used.'),
)
agreement_date = models.DateTimeField(
_('agreement date'),
blank=True,
null=True,
help_text=_('Indicates when the user has agreed with the policy.'),
)
preferred_language = models.CharField(max_length=10, blank=True)
competence = models.CharField(max_length=255, blank=True)
token_lifetime = models.PositiveIntegerField(
null=True,
help_text=_('Token lifetime in seconds.'),
validators=[validators.MinValueValidator(60)],
)
details = BetterJSONField(
blank=True,
default=dict,
help_text=_('Extra details from authentication backend.'),
)
backend_id = models.CharField(max_length=255, blank=True)
tracker = FieldTracker()
objects = UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def get_log_fields(self):
return (
'uuid',
'full_name',
'native_name',
self.USERNAME_FIELD,
'is_staff',
'is_support',
'token_lifetime',
)
def get_full_name(self):
# This method is used in django-reversion as name of revision creator.
return self.full_name
def get_short_name(self):
# This method is used in django-reversion as name of revision creator.
return self.full_name
def email_user(self, subject, message, from_email=None):
"""
Sends an email to this User.
"""
send_mail(subject, message, from_email, [self.email])
@classmethod
def get_permitted_objects(cls, user):
from waldur_core.structure.filters import filter_visible_users
queryset = User.objects.all()
if user.is_staff or user.is_support:
return queryset
else:
return filter_visible_users(queryset, user)
def clean(self):
super(User, self).clean()
# User email has to be unique or empty
if (self.email and User.objects.filter(email=self.email).exclude(
id=self.id).exists()):
raise ValidationError({
'email':
_('User with email "%s" already exists.') % self.email
})
@transaction.atomic
def create_request_for_update_email(self, email):
if User.objects.filter(email=email).exclude(id=self.id).exists():
raise ValidationError(
{'email': _('User with email "%s" already exists.') % email})
ChangeEmailRequest.objects.filter(user=self).delete()
change_request = ChangeEmailRequest.objects.create(
user=self,
email=email,
)
return change_request
def __str__(self):
if self.full_name:
return '%s (%s)' % (self.get_username(), self.full_name)
return self.get_username()
class UserProfile(AbstractBaseUser, PermissionsMixin):
# Fields from models.AbstractUser minus last_name and first_name,
# which we don't use; email is modified to make it indexed and unique.
email = models.EmailField(blank=False, db_index=True, unique=True)
is_staff = models.BooleanField(default=False)
is_active = models.BooleanField(default=True)
is_bot = models.BooleanField(default=False)
date_joined = models.DateTimeField(default=timezone.now)
is_mirror_dummy = models.BooleanField(default=False)
bot_owner = models.ForeignKey('self', null=True, on_delete=models.SET_NULL)
USERNAME_FIELD = 'email'
MAX_NAME_LENGTH = 100
# Our custom site-specific fields
full_name = models.CharField(max_length=MAX_NAME_LENGTH)
short_name = models.CharField(max_length=MAX_NAME_LENGTH)
# pointer points to Message.id, NOT UserMessage.id.
pointer = models.IntegerField()
last_pointer_updater = models.CharField(max_length=64)
realm = models.ForeignKey(Realm)
api_key = models.CharField(max_length=32)
### Notifications settings. ###
# Stream notifications.
enable_stream_desktop_notifications = models.BooleanField(default=False)
enable_stream_sounds = models.BooleanField(default=False)
# PM + @-mention notifications.
enable_desktop_notifications = models.BooleanField(default=True)
enable_sounds = models.BooleanField(default=True)
enable_offline_email_notifications = models.BooleanField(default=True)
enable_offline_push_notifications = models.BooleanField(default=True)
enable_digest_emails = models.BooleanField(default=True)
# Old notification field superseded by existence of stream notification
# settings.
default_desktop_notifications = models.BooleanField(default=True)
###
last_reminder = models.DateTimeField(default=timezone.now, null=True)
rate_limits = models.CharField(
default="", max_length=100) # comma-separated list of range:max pairs
# Default streams
default_sending_stream = models.ForeignKey('zerver.Stream',
null=True,
related_name='+')
default_events_register_stream = models.ForeignKey('zerver.Stream',
null=True,
related_name='+')
default_all_public_streams = models.BooleanField(default=False)
# UI vars
enter_sends = models.NullBooleanField(default=True)
autoscroll_forever = models.BooleanField(default=False)
left_side_userlist = models.BooleanField(default=False)
# display settings
twenty_four_hour_time = models.BooleanField(default=False)
# Hours to wait before sending another email to a user
EMAIL_REMINDER_WAITPERIOD = 24
# Minutes to wait before warning a bot owner that her bot sent a message
# to a nonexistent stream
BOT_OWNER_STREAM_ALERT_WAITPERIOD = 1
AVATAR_FROM_GRAVATAR = 'G'
AVATAR_FROM_USER = '******'
AVATAR_FROM_SYSTEM = 'S'
AVATAR_SOURCES = (
(AVATAR_FROM_GRAVATAR, 'Hosted by Gravatar'),
(AVATAR_FROM_USER, 'Uploaded by user'),
(AVATAR_FROM_SYSTEM, 'System generated'),
)
avatar_source = models.CharField(default=AVATAR_FROM_GRAVATAR,
choices=AVATAR_SOURCES,
max_length=1)
TUTORIAL_WAITING = 'W'
TUTORIAL_STARTED = 'S'
TUTORIAL_FINISHED = 'F'
TUTORIAL_STATES = ((TUTORIAL_WAITING, "Waiting"),
(TUTORIAL_STARTED, "Started"), (TUTORIAL_FINISHED,
"Finished"))
tutorial_status = models.CharField(default=TUTORIAL_WAITING,
choices=TUTORIAL_STATES,
max_length=1)
# Contains serialized JSON of the form:
# [("step 1", true), ("step 2", false)]
# where the second element of each tuple is if the step has been
# completed.
onboarding_steps = models.TextField(default=ujson.dumps([]))
invites_granted = models.IntegerField(default=0)
invites_used = models.IntegerField(default=0)
alert_words = models.TextField(default=ujson.dumps(
[])) # json-serialized list of strings
# Contains serialized JSON of the form:
# [["social", "mit"], ["devel", "ios"]]
muted_topics = models.TextField(default=ujson.dumps([]))
objects = UserManager()
def can_admin_user(self, target_user):
"""Returns whether this user has permission to modify target_user"""
if target_user.bot_owner == self:
return True
elif self.has_perm('administer', target_user.realm):
return True
else:
return False
def is_admin(self):
return self.has_perm('administer', self.realm)
def is_api_super_user(self):
# TODO: Remove API_SUPER_USERS hack; fixing this will require
# setting the email bot as a super user in the provision process.
return self.has_perm(
'api_super_user',
self.realm) or self.email in settings.API_SUPER_USERS
def last_reminder_tzaware(self):
if self.last_reminder is not None and timezone.is_naive(
self.last_reminder):
logging.warning(
"Loaded a user_profile.last_reminder for user %s that's not tz-aware: %s"
% (self.email, self.last_reminder))
return self.last_reminder.replace(tzinfo=timezone.utc)
return self.last_reminder
def __repr__(self):
return (u"<UserProfile: %s %s>" %
(self.email, self.realm)).encode("utf-8")
def __str__(self):
return self.__repr__()
@staticmethod
def emails_from_ids(user_ids):
rows = UserProfile.objects.filter(id__in=user_ids).values(
'id', 'email')
return {row['id']: row['email'] for row in rows}
def can_create_streams(self):
# Long term this might be an actual DB attribute. Short term and long term, we want
# this to be conceptually a property of the user, although it may actually be administered
# in a more complicated way, like certain realms may allow only admins to create streams.
return True
class User(AbstractBaseUser, PermissionsMixin):
class Meta:
app_label = 'accounts'
db_table = "auth_user"
username = models.CharField(
_('username'),
max_length=75,
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,
help_text="Full name of the user")
email = models.EmailField(_('email address'), max_length=254, unique=True)
title = models.CharField(max_length=100,
blank=True,
help_text="Title of the user")
phone = models.CharField(max_length=25,
blank=True,
help_text="Phone number of the user")
company = models.CharField(max_length=100,
blank=True,
help_text="Company of the user")
website = models.URLField(max_length=100,
blank=True,
help_text="Website of the user")
street_1 = models.CharField(max_length=100,
blank=True,
help_text="Street of the user")
street_2 = models.CharField(max_length=100,
blank=True,
help_text="APT/Building of the user")
city = models.CharField(max_length=100,
blank=True,
help_text="City of the user")
state = models.CharField(max_length=4,
blank=True,
choices=US_STATES,
help_text="State of the user")
country = models.CharField(max_length=50,
blank=True,
help_text="Country of the user")
zipcode = models.CharField(max_length=25,
blank=True,
help_text="Zipcode name of the user")
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)
password_hash = models.CharField(max_length=50,
null=True,
help_text="Forgot password hash")
objects = UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
def get_full_name(self):
return self.full_name
def get_short_name(self):
return self.username
class CustomUser(AbstractUser):
code = models.CharField(max_length=40, verbose_name='编码', blank=True)
mobile = models.CharField(max_length=32,
verbose_name='手机号码',
blank=True,
null=True)
username = models.CharField(max_length=100,
verbose_name='用户名',
blank=True,
null=True)
nickname = models.CharField(max_length=100,
verbose_name='昵称',
blank=True,
null=True)
password = models.CharField(
u'登录密码',
max_length=128,
help_text=
u'''请使用 '[algo]$[salt]$[hexdigest]' 这样的密码格式，或者 <a href="password/">点击此处</a> 修改该用户登录密码。'''
)
company = models.CharField(max_length=50,
verbose_name='公司',
blank=True,
null=True)
avatar = models.ImageField(upload_to=user_avatar_upload_to,
null=True,
blank=True,
verbose_name='用户头像')
type = models.ForeignKey(UserType,
verbose_name='用户类型',
blank=True,
null=True)
role = models.ForeignKey(UserRole,
verbose_name='用户角色',
blank=True,
null=True)
authority = models.ForeignKey(UserAuthority,
null=True,
blank=True,
verbose_name='用户权限')
is_available = models.BooleanField(default=False, verbose_name='是否可用')
is_superuser = models.BooleanField(default=False, verbose_name='是否管理员')
dt_created = models.DateTimeField(auto_now_add=True, verbose_name='创建于')
dt_updated = models.DateTimeField(auto_now=True, verbose_name='更新于')
groups = None # models.ManyToManyField(Group, related_name='custom_users', verbose_name=_('group'))
user_permissions = None # models.ManyToManyField(Permission, related_name='custom_users')
objects = UserManager()
available_objects = AvailableUserManager()
class Meta:
verbose_name = '用户'
verbose_name_plural = '用户'
get_latest_by = 'id'
def __unicode__(self):
return self.username
def generate_code(self):
m5 = hashlib.md5()
m5.update("%s-%s-%s-%s" %
(self.username.encode('utf-8'), self.mobile,
self.company.encode('utf-8'),
self.dt_created.strftime('%Y-%m-%d %H:%M:%S')))
return m5.hexdigest().upper()
def save(self, *args, **kwargs):
if not self.password:
self.password = make_password(settings.DEFAULT_PASSWORD)
if self.password and not is_password_usable(self.password):
self.password = make_password(self.password)
return super(CustomUser, self).save(*args, **kwargs)
def test_create_user_email_domain_normalize(self):
returned = UserManager.normalize_email('*****@*****.**')
self.assertEqual(returned, '*****@*****.**')
class User(BaseModel, AbstractBaseUser):
__core__ = True
id = BoundedAutoField(primary_key=True)
username = models.CharField(_("username"), max_length=128, unique=True)
# this column is called first_name for legacy reasons, but it is the entire
# display name
name = models.CharField(_("name"),
max_length=200,
blank=True,
db_column="first_name")
email = models.EmailField(_("email address"), blank=True, max_length=75)
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."),
)
is_superuser = models.BooleanField(
_("superuser status"),
default=False,
help_text=
_("Designates that this user has all permissions without explicitly assigning them."
),
)
is_managed = models.BooleanField(
_("managed"),
default=False,
help_text=_("Designates whether this user should be treated as "
"managed. Select this to disallow the user from "
"modifying their account (username, password, etc)."),
)
is_sentry_app = models.NullBooleanField(
_("is sentry app"),
null=True,
default=None,
help_text=_(
"Designates whether this user is the entity used for Permissions"
"on behalf of a Sentry App. Cannot login or use Sentry like a"
"normal User would."),
)
is_password_expired = models.BooleanField(
_("password expired"),
default=False,
help_text=_("If set to true then the user needs to change the "
"password on next sign in."),
)
last_password_change = models.DateTimeField(
_("date of last password change"),
null=True,
help_text=_("The date the password was changed last."),
)
flags = BitField(
flags=(
("newsletter_consent_prompt",
"Do we need to ask this user for newsletter consent?"),
(
"demo_mode",
"Mark an user as a demo user.",
),
),
default=0,
null=True,
)
session_nonce = models.CharField(max_length=12, null=True)
actor = FlexibleForeignKey("sentry.Actor",
db_index=True,
unique=True,
null=True,
on_delete=models.PROTECT)
date_joined = models.DateTimeField(_("date joined"), default=timezone.now)
last_active = models.DateTimeField(_("last active"),
default=timezone.now,
null=True)
objects = UserManager(cache_fields=["pk"])
USERNAME_FIELD = "username"
REQUIRED_FIELDS = ["email"]
class Meta:
app_label = "sentry"
db_table = "auth_user"
verbose_name = _("user")
verbose_name_plural = _("users")
__repr__ = sane_repr("id")
def delete(self):
if self.username == "sentry":
raise Exception(
'You cannot delete the "sentry" user as it is required by Sentry.'
)
avatar = self.avatar.first()
if avatar:
avatar.delete()
return super().delete()
def save(self, *args, **kwargs):
if not self.username:
self.username = self.email
return super().save(*args, **kwargs)
def has_perm(self, perm_name):
warnings.warn("User.has_perm is deprecated", DeprecationWarning)
return self.is_superuser
def has_module_perms(self, app_label):
warnings.warn("User.has_module_perms is deprecated",
DeprecationWarning)
return self.is_superuser
def get_unverified_emails(self):
return self.emails.filter(is_verified=False)
def get_verified_emails(self):
return self.emails.filter(is_verified=True)
def has_unverified_emails(self):
return self.get_unverified_emails().exists()
def get_label(self):
return self.email or self.username or self.id
def get_display_name(self):
return self.name or self.email or self.username
def get_full_name(self):
return self.name
def get_short_name(self):
return self.username
def get_salutation_name(self):
name = self.name or self.username.split("@", 1)[0].split(".", 1)[0]
first_name = name.split(" ", 1)[0]
return first_name.capitalize()
def get_avatar_type(self):
avatar = self.avatar.first()
if avatar:
return avatar.get_avatar_type_display()
return "letter_avatar"
def send_confirm_email_singular(self, email, is_new_user=False):
from sentry import options
from sentry.utils.email import MessageBuilder
if not email.hash_is_valid():
email.set_hash()
email.save()
context = {
"user":
self,
"url":
absolute_uri(
reverse("sentry-account-confirm-email",
args=[self.id, email.validation_hash])),
"confirm_email":
email.email,
"is_new_user":
is_new_user,
}
msg = MessageBuilder(
subject="{}Confirm Email".format(
options.get("mail.subject-prefix")),
template="sentry/emails/confirm_email.txt",
html_template="sentry/emails/confirm_email.html",
type="user.confirm_email",
context=context,
)
msg.send_async([email.email])
def send_confirm_emails(self, is_new_user=False):
email_list = self.get_unverified_emails()
for email in email_list:
self.send_confirm_email_singular(email, is_new_user)
def merge_to(from_user, to_user):
# TODO: we could discover relations automatically and make this useful
from sentry import roles
from sentry.models import (
Activity,
AuditLogEntry,
AuthIdentity,
Authenticator,
GroupAssignee,
GroupBookmark,
GroupSeen,
GroupShare,
GroupSubscription,
Identity,
OrganizationMember,
OrganizationMemberTeam,
UserAvatar,
UserEmail,
UserOption,
)
audit_logger.info("user.merge",
extra={
"from_user_id": from_user.id,
"to_user_id": to_user.id
})
for obj in OrganizationMember.objects.filter(user=from_user):
try:
with transaction.atomic():
obj.update(user=to_user)
# this will error if both users are members of obj.org
except IntegrityError:
pass
# identify the highest priority membership
# only applies if both users are members of obj.org
# if roles are different, grants combined user the higher of the two
to_member = OrganizationMember.objects.get(
organization=obj.organization_id, user=to_user)
if roles.get(obj.role).priority > roles.get(
to_member.role).priority:
to_member.update(role=obj.role)
for team in obj.teams.all():
try:
with transaction.atomic():
OrganizationMemberTeam.objects.create(
organizationmember=to_member, team=team)
# this will error if both users are on the same team in obj.org,
# in which case, no need to update anything
except IntegrityError:
pass
model_list = (
Authenticator,
GroupAssignee,
GroupBookmark,
GroupSeen,
GroupShare,
GroupSubscription,
Identity,
UserAvatar,
UserEmail,
UserOption,
)
for model in model_list:
for obj in model.objects.filter(user=from_user):
try:
with transaction.atomic():
obj.update(user=to_user)
except IntegrityError:
pass
Activity.objects.filter(user=from_user).update(user=to_user)
# users can be either the subject or the object of actions which get logged
AuditLogEntry.objects.filter(actor=from_user).update(actor=to_user)
AuditLogEntry.objects.filter(target_user=from_user).update(
target_user=to_user)
# remove any SSO identities that exist on from_user that might conflict
# with to_user's existing identities (only applies if both users have
# SSO identities in the same org), then pass the rest on to to_user
AuthIdentity.objects.filter(
user=from_user,
auth_provider__organization__in=AuthIdentity.objects.filter(
user=to_user).values("auth_provider__organization"),
).delete()
AuthIdentity.objects.filter(user=from_user).update(user=to_user)
def set_password(self, raw_password):
super().set_password(raw_password)
self.last_password_change = timezone.now()
self.is_password_expired = False
def refresh_session_nonce(self, request=None):
from django.utils.crypto import get_random_string
self.session_nonce = get_random_string(12)
if request is not None:
request.session["_nonce"] = self.session_nonce
def get_orgs(self):
from sentry.models import Organization, OrganizationMember, OrganizationStatus
return Organization.objects.filter(
status=OrganizationStatus.VISIBLE,
id__in=OrganizationMember.objects.filter(
user=self).values("organization"),
)
def get_orgs_require_2fa(self):
from sentry.models import Organization, OrganizationStatus
return Organization.objects.filter(
flags=models.F("flags").bitor(Organization.flags.require_2fa),
status=OrganizationStatus.VISIBLE,
member_set__user=self,
)
def clear_lost_passwords(self):
LostPasswordHash.objects.filter(user=self).delete()
def test_create_user_email_domain_normalize_with_whitespace(self):
returned = UserManager.normalize_email('email\ [email protected]')
self.assertEqual(returned, 'email\ [email protected]')
class User(AbstractBaseUser, PermissionsMixin):
uid = models.UUIDField(primary_key=True,
default=uuid.uuid4,
editable=False)
phone = models.CharField(max_length=11,
null=False,
unique=True,
db_index=True)
avatar = models.FileField(upload_to="avatars/",
default="avatars/default.jpg",
verbose_name="头像",
blank=True)
profile = models.OneToOneField(to="Profile",
to_field="push_id",
null=True,
blank=False,
on_delete=models.SET_NULL)
create_time = models.DateTimeField(auto_now=True)
username_validator = UnicodeUsernameValidator()
USERNAME_FIELD = 'phone'
username = models.CharField(
"username",
max_length=20,
help_text=
"Required. 10 characters or fewer. Letters, digits and @/./+/-/_ only.",
validators=[username_validator],
)
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)
objects = UserManager()
EMAIL_FIELD = 'email'
REQUIRED_FIELDS = ['email']
class Meta:
verbose_name = "用户"
verbose_name_plural = "用户"
swappable = 'AUTH_USER_MODEL'
def clean(self):
super().clean()
self.email = self.__class__.objects.normalize_email(self.email)
def get_full_name(self):
"""
Return the first_name plus the last_name, with a space in between.
"""
full_name = '%s %s' % self.username
return full_name.strip()
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(PermissionsMixin):
"""Custom User model.
It overloads the way passwords are stored into the database. The
main reason to change this mechanism is to ensure the
compatibility with the way Dovecot stores passwords.
It also adds new attributes and methods.
"""
username = models.CharField(max_length=254, unique=True)
first_name = models.CharField(max_length=30, blank=True)
last_name = models.CharField(max_length=30, blank=True)
email = models.EmailField(max_length=254, blank=True, db_index=True)
is_staff = models.BooleanField(default=False, db_index=True)
is_active = models.BooleanField(default=True, db_index=True)
date_joined = models.DateTimeField(default=timezone.now)
is_local = models.BooleanField(default=True, db_index=True)
master_user = models.BooleanField(
ugettext_lazy("Allow mailboxes access"),
default=False,
help_text=ugettext_lazy(
"Allow this administrator to access user mailboxes"))
password = models.CharField(ugettext_lazy('password'), max_length=256)
last_login = models.DateTimeField(ugettext_lazy('last login'),
blank=True,
null=True)
language = models.CharField(
max_length=10,
default="en",
choices=constants.LANGUAGES,
help_text=ugettext_lazy("Prefered language to display pages."))
phone_number = models.CharField(ugettext_lazy("Phone number"),
max_length=128,
blank=True,
null=True)
secondary_email = models.EmailField(
ugettext_lazy("Secondary email"),
max_length=254,
blank=True,
null=True,
help_text=ugettext_lazy(
"An alternative e-mail address, can be used for recovery needs."))
objects = UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
class Meta:
ordering = ["username"]
index_together = [['email', 'is_active']]
password_expr = re.compile(r'\{([\w\-]+)\}(.+)')
def delete(self, fromuser, *args, **kwargs):
"""Custom delete method
To check permissions properly, we need to make a distinction
between 2 cases:
* If the user owns a mailbox, the check is made on that object
(useful for domain admins)
* Otherwise, the check is made on the user
"""
from modoboa.lib.permissions import \
get_object_owner, grant_access_to_object, ungrant_access_to_object
if fromuser == self:
raise PermDeniedException(_("You can't delete your own account"))
if not fromuser.can_access(self):
raise PermDeniedException
owner = get_object_owner(self)
for ooentry in self.objectaccess_set.filter(is_owner=True):
if ooentry.content_object is not None:
grant_access_to_object(owner, ooentry.content_object, True)
ungrant_access_to_object(ooentry.content_object, self)
events.raiseEvent("AccountDeleted", self, fromuser, **kwargs)
ungrant_access_to_object(self)
super(User, self).delete()
def _crypt_password(self, raw_value):
"""Crypt the local password using the appropriate scheme.
In case we don't find the scheme (for example when the
management framework is used), we load the parameters and try
one more time.
"""
try:
scheme = parameters.get_admin("PASSWORD_SCHEME")
except parameters.NotDefined:
from modoboa.core import load_core_settings
load_core_settings()
scheme = parameters.get_admin("PASSWORD_SCHEME")
if isinstance(raw_value, unicode):
raw_value = raw_value.encode("utf-8")
return get_password_hasher(scheme.upper())().encrypt(raw_value)
def set_password(self, raw_value, curvalue=None):
"""Password update
Update the current mailbox's password with the given clear
value. This value is encrypted according to the defined method
before it is saved.
:param raw_value: the new password's value
:param curvalue: the current password (for LDAP authentication)
"""
if self.is_local:
self.password = self._crypt_password(raw_value)
else:
if not ldap_available:
raise InternalError(
_("Failed to update password: LDAP module not installed"))
LDAPAuthBackend().update_user_password(self.username, curvalue,
raw_value)
events.raiseEvent("PasswordUpdated", self, raw_value, self.pk is None)
def check_password(self, raw_value):
"""Compare raw_value to current password."""
match = self.password_expr.match(self.password)
if match is None:
return False
if isinstance(raw_value, unicode):
raw_value = raw_value.encode("utf-8")
scheme = match.group(1)
val2 = match.group(2)
hasher = get_password_hasher(scheme)
return hasher().verify(raw_value, val2)
def get_username(self):
"Return the identifying username for this User"
return getattr(self, self.USERNAME_FIELD)
def __str__(self):
return smart_text(self.get_username())
def natural_key(self):
return (self.get_username(), )
def is_anonymous(self):
"""
Always returns False. This is a way of comparing User objects to
anonymous users.
"""
return False
def is_authenticated(self):
"""
Always return True. This is a way to tell if the user has been
authenticated in templates.
"""
return True
def set_unusable_password(self):
# Sets a value that will never be a valid hash
self.password = make_password(None)
def has_usable_password(self):
return is_password_usable(self.password)
@property
def tags(self):
return [{
"name": "account",
"label": _("account"),
"type": "idt"
}, {
"name": self.group,
"label": self.group,
"type": "grp",
"color": "info"
}]
@property
def fullname(self):
if self.first_name != u"":
return u"%s %s" % (self.first_name, self.last_name)
return self.username
@property
def identity(self):
return self.username
@property
def name_or_rcpt(self):
if self.first_name != "":
return "%s %s" % (self.first_name, self.last_name)
return "----"
@property
def group(self):
if self.is_superuser:
return "SuperAdmins"
try:
return self.groups.all()[0].name
except IndexError:
return "---"
@property
def enabled(self):
return self.is_active
@property
def encoded_address(self):
from email.header import Header
if self.first_name != "" or self.last_name != "":
return "%s <%s>" % \
(Header(self.fullname, 'utf8').encode(), self.email)
return self.email
def belongs_to_group(self, name):
"""Simple shortcut to check if this user is a member of a
specific group.
:param name: the group's name
:return: a boolean
"""
try:
self.groups.get(name=name)
except Group.DoesNotExist:
return False
return True
def is_owner(self, obj):
"""Tell is the user is the unique owner of this object
:param obj: an object inheriting from ``models.Model``
:return: a boolean
"""
ct = ContentType.objects.get_for_model(obj)
try:
ooentry = self.objectaccess_set.get(content_type=ct,
object_id=obj.id)
except ObjectAccess.DoesNotExist:
return False
return ooentry.is_owner
def can_access(self, obj):
"""Check if the user can access a specific object
This function is recursive: if the given user hasn't got
direct access to this object and if he has got access to other
``User`` objects, we check if one of those users owns the
object.
:param obj: a admin object
:return: a boolean
"""
if self.is_superuser:
return True
ct = ContentType.objects.get_for_model(obj)
try:
ooentry = self.objectaccess_set.get(content_type=ct,
object_id=obj.id)
except ObjectAccess.DoesNotExist:
pass
else:
return True
if ct.model == "user":
return False
ct = ContentType.objects.get_for_model(self)
qs = self.objectaccess_set.filter(content_type=ct)
for ooentry in qs.all():
if ooentry.content_object.is_owner(obj):
return True
return False
def set_role(self, role):
"""Set administrative role for this account
:param string role: the role to set
"""
if role is None or self.group == role:
return
events.raiseEvent("RoleChanged", self, role)
self.groups.clear()
if role == "SuperAdmins":
self.is_superuser = True
else:
if self.is_superuser:
ObjectAccess.objects.filter(user=self).delete()
self.is_superuser = False
try:
self.groups.add(Group.objects.get(name=role))
except Group.DoesNotExist:
self.groups.add(Group.objects.get(name="SimpleUsers"))
if self.group != "SimpleUsers" and not self.can_access(self):
from modoboa.lib.permissions import grant_access_to_object
grant_access_to_object(self, self)
self.save()
def post_create(self, creator):
from modoboa.lib.permissions import grant_access_to_object
grant_access_to_object(creator, self, is_owner=True)
events.raiseEvent("AccountCreated", self)
def save(self, *args, **kwargs):
if "creator" in kwargs:
creator = kwargs["creator"]
del kwargs["creator"]
else:
creator = None
super(User, self).save(*args, **kwargs)
if creator is not None:
self.post_create(creator)
def from_csv(self, user, row, crypt_password=True):
"""Create a new account from a CSV file entry.
The expected order is the following::
"account", loginname, password, first name, last name, enabled, group
Additional fields can be added using the *AccountImported* event.
:param user: a ``core.User`` instance
:param row: a list containing the expected information
:param crypt_password:
"""
from modoboa.lib.permissions import get_account_roles
if len(row) < 7:
raise BadRequest(_("Invalid line"))
desired_role = row[6].strip()
if not user.is_superuser:
allowed_roles = get_account_roles(user)
allowed_roles = [role[0] for role in allowed_roles]
if desired_role not in allowed_roles:
raise PermDeniedException(
_("You can't import an account with a role greater than "
"yours"))
self.username = row[1].strip()
try:
User.objects.get(username=self.username)
except User.DoesNotExist:
pass
else:
raise Conflict
if desired_role == "SimpleUsers":
if len(row) < 8 or not row[7].strip():
raise BadRequest(
_("The simple user '%s' must have a valid email address" %
self.username))
if self.username != row[7].strip():
raise BadRequest(
_("username and email fields must not differ for '%s'" %
self.username))
if crypt_password:
self.set_password(row[2].strip())
else:
self.password = row[2].strip()
self.first_name = row[3].strip()
self.last_name = row[4].strip()
self.is_active = (row[5].strip() in ["True", "1", "yes", "y"])
self.save()
self.set_role(desired_role)
self.post_create(user)
if len(row) < 8:
return
events.raiseEvent("AccountImported", user, self, row[7:])
def to_csv(self, csvwriter):
"""Export this account.
The CSV format is used to export.
:param csvwriter: csv object
"""
row = [
"account",
self.username.encode("utf-8"),
self.password.encode("utf-8"),
self.first_name.encode("utf-8"),
self.last_name.encode("utf-8"), self.is_active, self.group,
self.email.encode("utf-8")
]
row += events.raiseQueryEvent("AccountExported", self)
csvwriter.writerow(row)
class UserManager(BaseUserManager.from_queryset(UserQuerySet)):
def get_or_create_github_user(self):
return self.get_or_create(username=settings.GITHUB_USER_NAME)[0]
def _create_user(self, username, email, password, **extra_fields):
if 'is_staff' in extra_fields:
del extra_fields['is_staff']
return DjangoUserManager._create_user(self, username, email, password,
**extra_fields)
class User(AbstractBaseUser, PermissionsMixin):
username = models.CharField(
_('username'),
max_length=255,
unique=True,
help_text=_('Required. 30 characters or fewer. Letters, numbers and '
'/./-/_ characters'),
validators=[
validators.RegexValidator(re.compile('^[\w.-]+$'),
_('Enter a valid username.'), 'invalid')
])
email = models.EmailField(_('email address'),
max_length=255,
blank=True,
unique=True)
is_active = models.BooleanField(
_('active'),
default=True,
help_text=_('Designates whether this user should be treated as '
'active. Unselect this instead of deleting accounts.'))
full_name = models.CharField(_('full name'), max_length=256, blank=True)
color = models.CharField(max_length=9,
null=False,
blank=True,
default=generate_random_hex_color,
verbose_name=_("color"))
bio = models.TextField(null=False,
blank=True,
default="",
verbose_name=_("biography"))
photo = models.FileField(upload_to=get_user_file_path,
max_length=500,
null=True,
blank=True,
verbose_name=_("photo"))
date_joined = models.DateTimeField(_('date joined'), default=timezone.now)
lang = models.CharField(max_length=20,
null=True,
blank=True,
default="",
verbose_name=_("default language"))
timezone = models.CharField(max_length=20,
null=True,
blank=True,
default="",
verbose_name=_("default timezone"))
colorize_tags = models.BooleanField(null=False,
blank=True,
default=False,
verbose_name=_("colorize tags"))
token = models.CharField(max_length=200,
null=True,
blank=True,
default=None,
verbose_name=_("token"))
email_token = models.CharField(max_length=200,
null=True,
blank=True,
default=None,
verbose_name=_("email token"))
new_email = models.EmailField(_('new email address'),
null=True,
blank=True)
is_system = models.BooleanField(null=False, blank=False, default=False)
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
objects = UserManager()
class Meta:
verbose_name = "user"
verbose_name_plural = "users"
ordering = ["username"]
permissions = (("view_user", "Can view user"), )
def __str__(self):
return self.get_full_name()
def get_short_name(self):
"Returns the short name for the user."
return self.username
def get_full_name(self):
return self.full_name or self.username or self.email
def save(self, *args, **kwargs):
get_token_for_user(self, "cancel_account")
super().save(*args, **kwargs)
def cancel(self):
self.username = slugify_uniquely("deleted-user",
User,
slugfield="username")
self.email = "{}@taiga.io".format(self.username)
self.is_active = False
self.full_name = "Deleted user"
self.color = ""
self.bio = ""
self.lang = ""
self.timezone = ""
self.colorize_tags = True
self.token = None
self.set_unusable_password()
self.save()
self.auth_data.all().delete()
def test_make_random_password(self):
allowed_chars = 'abcdefg'
password = UserManager().make_random_password(5, allowed_chars)
self.assertEqual(len(password), 5)
for char in password:
self.assertIn(char, allowed_chars)
class Profile(User):
avatar = models.ImageField(upload_to='media', default='default.png')
objects = UserManager()
def __unicode__(self):
return self.username
class User(AbstractUser):
objects = UserManager()
class Meta(object):
app_label = 'accounts'
class User(AbstractBaseUser, PermissionsMixin):
uuid = models.CharField(max_length=32, editable=False, null=False,
blank=False, unique=True, default=get_default_uuid)
username = models.CharField(_("username"), max_length=255, unique=True,
help_text=_("Required. 30 characters or fewer. Letters, numbers and "
"/./-/_ characters"),
validators=[
validators.RegexValidator(re.compile(r"^[\w.-]+$"), _("Enter a valid username."), "invalid")
])
email = models.EmailField(_("email address"), max_length=255, blank=True, unique=True)
is_active = models.BooleanField(_("active"), default=True,
help_text=_("Designates whether this user should be treated as "
"active. Unselect this instead of deleting accounts."))
full_name = models.CharField(_("full name"), max_length=256, blank=True)
color = models.CharField(max_length=9, null=False, blank=True, default=generate_random_hex_color,
verbose_name=_("color"))
bio = models.TextField(null=False, blank=True, default="", verbose_name=_("biography"))
photo = models.FileField(upload_to=get_user_file_path,
max_length=500, null=True, blank=True,
verbose_name=_("photo"))
date_joined = models.DateTimeField(_("date joined"), default=timezone.now)
accepted_terms = models.BooleanField(_("accepted terms"), default=True)
read_new_terms = models.BooleanField(_("new terms read"), default=False)
lang = models.CharField(max_length=20, null=True, blank=True, default="",
verbose_name=_("default language"))
theme = models.CharField(max_length=100, null=True, blank=True, default="",
verbose_name=_("default theme"))
timezone = models.CharField(max_length=20, null=True, blank=True, default="",
verbose_name=_("default timezone"))
colorize_tags = models.BooleanField(null=False, blank=True, default=False,
verbose_name=_("colorize tags"))
token = models.CharField(max_length=200, null=True, blank=True, default=None,
verbose_name=_("token"))
email_token = models.CharField(max_length=200, null=True, blank=True, default=None,
verbose_name=_("email token"))
new_email = models.EmailField(_("new email address"), null=True, blank=True)
verified_email = models.BooleanField(null=False, blank=False, default=True)
is_system = models.BooleanField(null=False, blank=False, default=False)
max_private_projects = models.IntegerField(null=True, blank=True,
default=settings.MAX_PRIVATE_PROJECTS_PER_USER,
verbose_name=_("max number of owned private projects"))
max_public_projects = models.IntegerField(null=True, blank=True,
default=settings.MAX_PUBLIC_PROJECTS_PER_USER,
verbose_name=_("max number of owned public projects"))
max_memberships_private_projects = models.IntegerField(null=True, blank=True,
default=settings.MAX_MEMBERSHIPS_PRIVATE_PROJECTS,
verbose_name=_("max number of memberships for "
"each owned private project"))
max_memberships_public_projects = models.IntegerField(null=True, blank=True,
default=settings.MAX_MEMBERSHIPS_PUBLIC_PROJECTS,
verbose_name=_("max number of memberships for "
"each owned public project"))
_cached_memberships = None
_cached_liked_ids = None
_cached_watched_ids = None
_cached_notify_levels = None
USERNAME_FIELD = "username"
REQUIRED_FIELDS = ["email"]
objects = UserManager()
class Meta:
verbose_name = "user"
verbose_name_plural = "users"
ordering = ["username"]
def __str__(self):
return self.get_full_name()
def _fill_cached_memberships(self):
self._cached_memberships = {}
qs = self.memberships.select_related("user", "project", "role")
for membership in qs.all():
self._cached_memberships[membership.project.id] = membership
@property
def cached_memberships(self):
if self._cached_memberships is None:
self._fill_cached_memberships()
return self._cached_memberships.values()
def cached_membership_for_project(self, project):
if self._cached_memberships is None:
self._fill_cached_memberships()
return self._cached_memberships.get(project.id, None)
def is_fan(self, obj):
if self._cached_liked_ids is None:
self._cached_liked_ids = set()
for like in self.likes.select_related("content_type").all():
like_id = "{}-{}".format(like.content_type.id, like.object_id)
self._cached_liked_ids.add(like_id)
obj_type = ContentType.objects.get_for_model(obj)
obj_id = "{}-{}".format(obj_type.id, obj.id)
return obj_id in self._cached_liked_ids
def is_watcher(self, obj):
if self._cached_watched_ids is None:
self._cached_watched_ids = set()
for watched in self.watched.select_related("content_type").all():
watched_id = "{}-{}".format(watched.content_type.id, watched.object_id)
self._cached_watched_ids.add(watched_id)
notify_policies = self.notify_policies.select_related("project")\
.exclude(notify_level=NotifyLevel.none)
for notify_policy in notify_policies:
obj_type = ContentType.objects.get_for_model(notify_policy.project)
watched_id = "{}-{}".format(obj_type.id, notify_policy.project.id)
self._cached_watched_ids.add(watched_id)
obj_type = ContentType.objects.get_for_model(obj)
obj_id = "{}-{}".format(obj_type.id, obj.id)
return obj_id in self._cached_watched_ids
def get_notify_level(self, project):
if self._cached_notify_levels is None:
self._cached_notify_levels = {}
for notify_policy in self.notify_policies.select_related("project"):
self._cached_notify_levels[notify_policy.project.id] = notify_policy.notify_level
return self._cached_notify_levels.get(project.id, None)
def get_short_name(self):
"Returns the short name for the user."
return self.username
def get_full_name(self):
return self.full_name or self.username or self.email
def contacts_visible_by_user(self, user):
qs = User.objects.filter(is_active=True)
project_ids = services.get_visible_project_ids(self, user)
qs = qs.filter(memberships__project_id__in=project_ids)
qs = qs.exclude(id=self.id)
return qs
def save(self, *args, **kwargs):
get_token_for_user(self, "cancel_account")
super().save(*args, **kwargs)
def cancel(self):
with advisory_lock("delete-user"):
deleted_user_prefix = "deleted-user-{}".format(timestamp_ms())
self.username = slugify_uniquely(deleted_user_prefix, User, slugfield="username")
self.email = "{}@taiga.io".format(self.username)
self.is_active = False
self.full_name = "Deleted user"
self.color = ""
self.bio = ""
self.lang = ""
self.theme = ""
self.timezone = ""
self.colorize_tags = True
self.token = None
self.set_unusable_password()
self.photo = None
self.save()
self.auth_data.all().delete()
# Blocking all owned projects
self.owned_projects.update(blocked_code=BLOCKED_BY_OWNER_LEAVING)
# Remove all memberships
self.memberships.all().delete()
def test_create_user_email_domain_normalize_rfc3696(self):
# According to http://tools.ietf.org/html/rfc3696#section-3
# the "@" symbol can be part of the local part of an email address
returned = UserManager.normalize_email(r'Abc\@[email protected]')
self.assertEqual(returned, r'Abc\@[email protected]')
class CustomUser(AbstractBaseUser, PermissionsMixin):
# ユーザーのID
user_id = models.AutoField(primary_key=True, verbose_name="ユーザーID")
# ユーザー名
username = models.CharField(max_length=20,
verbose_name='ユーザー名',
unique=True)
# メールアドレス
email = models.EmailField('メールアドレス')
# プロフィール画像
prof_img = models.ImageField(upload_to='user/',
verbose_name='プロフィール画像',
null=True,
blank=True,
default='user/default.png')
# 自己紹介文
intro = models.TextField(verbose_name='自己紹介',
max_length=300,
null=True,
blank=True)
# 大学名
univ_name = models.CharField(verbose_name='大学名',
max_length=30,
null=True,
blank=True)
# 専攻
major = models.CharField(verbose_name='学部・学科・専攻',
max_length=50,
null=True,
blank=True)
created_at = models.DateTimeField(auto_now_add=True)
# ポートフォリオ
portfolio = models.URLField(verbose_name='ポートフォリオ', null=True, blank=True)
# 使わないからNoneにしておく
first_name = None
last_name = None
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.'),
)
objects = UserManager()
EMAIL_FIELD = 'email'
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = []
class Meta:
verbose_name = ('user')
verbose_name_plural = ('users')
def clean(self):
super().clean()
self.email = self.__class__.objects.normalize_email(self.email)
class User(AbstractUser):
objects = UserManager()
class UserProfile(AbstractUser, CoreModel):
USER_TYPE_CHOICES = (
(0, "后台用户"),
(1, "前台用户"),
)
objects = UserManager()
username = CharField(max_length=150,
unique=True,
db_index=True,
verbose_name='用户账号')
secret = CharField(max_length=255, default=uuid4, verbose_name='加密秘钥')
email = CharField(max_length=255, verbose_name="邮箱", null=True, blank=True)
mobile = CharField(max_length=255,
verbose_name="电话",
null=True,
blank=True)
avatar = TextField(verbose_name="头像", null=True, blank=True)
name = CharField(max_length=40, verbose_name="姓名")
gender = CharField(max_length=8, verbose_name="性别", null=True, blank=True)
remark = TextField(verbose_name="备注", null=True)
user_type = IntegerField(default=0, verbose_name="用户类型")
post = ManyToManyField(to='permission.Post',
verbose_name='关联岗位',
db_constraint=False)
role = ManyToManyField(to='permission.Role',
verbose_name='关联角色',
db_constraint=False)
dept = ForeignKey(to='permission.Dept',
verbose_name='归属部门',
on_delete=CASCADE,
db_constraint=False,
null=True,
blank=True)
@property
def get_user_interface_dict(self):
interface_dict = cache.get(
f'permission_interface_dict_{self.username}', {})
if not interface_dict:
for ele in self.role.filter(status='1', menu__status='1').values(
'menu__interface_path',
'menu__interface_method').distinct():
interface_path = ele.get('menu__interface_path')
if interface_path is None or interface_path == '':
continue
if ele.get('menu__interface_method') in interface_dict:
interface_dict[ele.get('menu__interface_method',
'')].append(interface_path)
else:
interface_dict[ele.get('menu__interface_method',
'')] = [interface_path]
cache.set(f'permission_interface_dict_{self.username}',
interface_dict, 84600)
return interface_dict
@property
def delete_cache(self):
"""
清空缓存中的接口列表
:return:
"""
return cache.delete(f'permission_interface_dict_{self.username}')
class Meta:
abstract = settings.AUTH_USER_MODEL != 'permission.UserProfile'
verbose_name = '用户管理'
verbose_name_plural = verbose_name
def __str__(self):
if self.name:
return f"{self.username}({self.name})"
return f"{self.username}"
class AbstractUser(AbstractBaseUser, PermissionsMixin):
"""
An abstract base class implementing a fully featured User model with
admin-compliant permissions.
Username and password are required. Other fields are optional.
"""
username_validator = UnicodeUsernameValidator(
) if six.PY3 else ASCIIUsernameValidator()
username = models.CharField(
_('username'),
max_length=150,
db_column='user_name',
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."),
},
)
is_staff = models.BooleanField(
_('staff status'),
db_column='user_is_staff',
default=False,
help_text=_(
'Designates whether the user can log into this admin site.'),
)
is_active = models.CharField(
_('active'),
db_column='user_is_active',
max_length=1,
default='Y',
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 = UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
class Meta:
db_table = 'oh_user'
verbose_name = _('user')
verbose_name_plural = _('users')
abstract = True
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
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)
class AtmosphereUser(AbstractBaseUser, PermissionsMixin):
uuid = models.UUIDField(default=uuid.uuid4, unique=True, editable=False)
selected_identity = models.ForeignKey('Identity', blank=True, null=True)
end_date = models.DateTimeField(null=True, blank=True)
# Ripped from django.contrib.auth.models to force a larger max_length:
username = models.CharField(
_('username'),
max_length=256,
unique=True,
help_text=
_('Required. 256 characters or fewer. Letters, digits and @/./+/-/_ only.'
),
validators=[
validators.RegexValidator(
r'^[\w.@+-]+$',
_('Enter a valid username. This value may contain only '
'letters, numbers '
'and @/./+/-/_ characters.')),
],
error_messages={
'unique': _("A user with that username already exists."),
},
)
first_name = models.CharField(_('first name'), max_length=64, blank=True)
last_name = models.CharField(_('last name'), max_length=256, blank=True)
# These methods unchanged from 'AbstractUser'
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)
objects = UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
class Meta:
db_table = 'atmosphere_user'
app_label = 'core'
def get_profile(self):
"""
"""
from core.models.profile import UserProfile
return UserProfile.objects.filter(
user__username=self.username).distinct().get()
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
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)
# END-rip.
def is_admin(self):
if self.is_superuser or self.is_staff:
return True
return False
def all_projects(self):
from core.models.project import Project
p_qs = Project.objects.none()
for group in self.group_set.all():
p_qs |= group.projects.all()
return p_qs
def group_ids(self):
return self.group_set.values_list('id', flat=True)
def provider_ids(self):
return self.identity_set.values_list('provider', flat=True)
def user_quota(self):
identity = self.select_identity()
return identity.quota
def is_expired(self):
"""
Call expiration plugin to determine if user is expired
"""
_is_expired = ExpirationPluginManager.is_expired(self)
return _is_expired
def is_valid(self):
"""
Call validation plugin to determine user validity
"""
_is_valid = ValidationPluginManager.is_valid(self)
return _is_valid
@property
def is_enabled(self):
"""
User is enabled if:
1. They do not have an end_date
_OR_ They have an end_date that is not past the current time
2. The 'is_active' flag is True
"""
now_time = timezone.now()
return self.is_active and \
(not self.end_date or self.end_date > now_time)
@property
def current_providers(self):
from core.models import Provider
all_providers = Provider.objects.none()
for group in self.group_set.all():
all_providers |= Provider.objects.filter(
id__in=group.current_identities.values_list('provider',
flat=True))
return all_providers
@property
def current_identities(self):
from core.models import Identity
all_identities = Identity.objects.none()
for group in self.group_set.all():
all_identities |= group.current_identities.all()
return all_identities
@classmethod
def for_allocation_source(cls, allocation_source_name):
from core.models import UserAllocationSource
user_ids = UserAllocationSource.objects.filter(
allocation_source__name=allocation_source_name).values_list(
'user', flat=True)
return AtmosphereUser.objects.filter(id__in=user_ids)
def can_use_identity(self, identity_id):
return self.current_identities.filter(id=identity_id).count() > 0
def select_identity(self):
"""
Set, save and return an active selected_identity for the user.
"""
# Return previously selected identity
if settings.AUTO_CREATE_NEW_ACCOUNTS:
new_identities = create_new_accounts(self.username)
if self.selected_identity and self.selected_identity.is_active(
user=self):
return self.selected_identity
else:
self.selected_identity = get_default_identity(self.username)
if self.selected_identity:
self.save()
return self.selected_identity
from core.models import IdentityMembership
for group in self.group_set.all():
membership = IdentityMembership.get_membership_for(group.name)
if not membership:
continue
self.selected_identity = membership.identity
if self.selected_identity and self.selected_identity.is_active():
logger.debug("Selected Identity:%s" % self.selected_identity)
self.save()
return self.selected_identity
def volume_set(self):
from core.models import Volume
volume_db_ids = [
source.volume.id
for source in self.source_set.filter(volume__isnull=False)
]
return Volume.objects.filter(id__in=volume_db_ids)
def email_hash(self):
m = md5()
m.update(self.user.email)
return m.hexdigest()
class User(AbstractBaseUser, PermissionsMixin):
IS_VET = [3, 4, 5]
IS_OWNER = [1, 2]
username = models.CharField(max_length=100, unique=True)
email = models.EmailField(max_length=100, unique=True)
full_name = models.CharField(max_length=100)
is_active = models.BooleanField(default=True)
is_staff = models.BooleanField(default=False)
stripe_token = models.CharField(max_length=100, null=True, blank=True)
add_paid_post = models.BooleanField(default=True)
follows = models.ManyToManyField('users.user',
related_name="followed_by",
blank=True)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
blur_images = models.BooleanField(default=False)
interested_notification = models.BooleanField(default=True)
vet_reply_notification = models.BooleanField(default=True)
comments_notification = models.BooleanField(default=True)
comments_like_notification = models.BooleanField(default=True)
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
objects = UserManager()
def __unicode__(self):
return u'%d %s' % (self.id, self.username)
def __str__(self):
return self.email
def get_short_name(self):
return self.full_name
def is_vet(self):
if hasattr(self, 'groups'):
return self.groups.pk in self.IS_VET
else:
return False
def is_vet_student(self):
if hasattr(self, 'groups'):
return self.groups.id == 4
else:
return False
def get_label(self):
return settings.APP_LABEL.get(self.get_group_id(), '')
def get_token(self):
return self.auth_token.key if self.auth_token else None
def save(self, *args, **kwargs):
if self.is_vet():
self.blur_images = False
super(User, self).save(*args, **kwargs)
def get_group_id(self, *args, **kwargs):
return self.groups.id if hasattr(self, 'groups') else None
class CustomUser(AbstractBaseUser, PermissionsMixin):
"""
An abstract base class implementing a fully featured User model with
admin-compliant permissions.
Username, password and email are required. Other fields are optional.
"""
username = models.CharField(
_('username'),
max_length=100,
unique=True,
help_text=_('Character length may be maxiumum 100'),
validators=[
validators.RegexValidator(r'^[\w.@+-]+$',
_('Type correct username'), 'wrong')
])
first_name = models.CharField(_('First name'), max_length=255, blank=True)
last_name = models.CharField(_('Last name'), max_length=255, blank=True)
email = models.EmailField(_('Email address'), max_length=255, unique=True)
# birthdate = models.DateField(verbose_name="Birth day",blank=True,null=True)
profile_picture = models.ImageField(upload_to=file_path_and_rename,
null=True,
blank=True)
verified = models.BooleanField(default=False, verbose_name="Verified")
phone = models.CharField(max_length=100,
verbose_name="Phone",
null=True,
blank=True)
slug = models.SlugField(null=True, blank=True)
usertype = models.IntegerField(choices=USERTYPES_CHOICES,
verbose_name="User Type",
null=True,
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)
# objects = CustomUserManager()
objects = UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
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
def __str__(self):
return "{} {}".format(self.first_name, self.last_name)
def save(self, *args, **kwargs):
super(CustomUser, self).save(*args, **kwargs)
self.slug = slugify("{}{}".format(
self.first_name,
str(timezone.now().timestamp()).replace('.', '-')))
super(CustomUser, self).save(*args, **kwargs)
class User(AbstractBaseUser, PermissionsMixin):
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."),
},
)
first_name = models.CharField(_('first name'), max_length=30, blank=True)
last_name = models.CharField(_('last name'), max_length=150, blank=True)
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)
objects = UserManager()
EMAIL_FIELD = 'email'
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
abstract = False
def clean(self):
super().clean()
self.email = self.__class__.objects.normalize_email(self.email)
def get_full_name(self):
"""
Return 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):
"""Return the short name for the user."""
return self.first_name
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)
