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)