Exemple #1
0
    def post(self, request):
        form = self.form_class(request.POST)
        if form.is_valid():
            user = request.user
            pw = form.cleaned_data['password2']
            user.set_password(pw)
            password_changed(pw)
            user.save()
            user = authenticate(email=user.email, password=pw)
            login(request, user)
            pk = request.user.pk
            if hasattr(user, 'h_admin'):
                return HttpResponseRedirect(
                    reverse('h_admin:profile', args=[pk]))
            elif hasattr(user, 'patient'):
                return HttpResponseRedirect(
                    reverse('accounts:patientprofile', args=[pk]))
            elif hasattr(user, 'doctor'):
                return HttpResponseRedirect(
                    reverse('doctor:profile', args=[pk]))
            elif hasattr(user, 'nurse'):
                return HttpResponseRedirect(reverse('nurse:profile',
                                                    args=[pk]))

        return render(request, self.template_name, {'form': form})
Exemple #2
0
 def save(self, *args, **kwargs):
     if not self.displayName:
         self.displayName = self.username
     super().save(*args, **kwargs)
     if self._password is not None:
         password_validation.password_changed(self._password, self)
         self._password = None
Exemple #3
0
 def save(self, *args, **kwargs):
     if self._password is not None:
         password_validation.password_changed(self._password, self)
         self._password = None
     if not self.id:
         self.id = generate_id()
         self.date_joined = timezone.now()
         if not self.username:
             self.username = self.create_unique_username()
         # using your function as above or anything else
         success = False
         failures = 0
         while not success:
             try:
                 super(User, self).save(*args, **kwargs)
             except IntegrityError:
                 failures += 1
                 if failures > 5:  # or some other arbitrary cutoff point at which things are clearly wrong
                     raise KeyError
                 else:
                     # looks like a collision, try another random value
                     self.id = generate_id()
             else:
                 success = True
     else:
         super(User, self).save(*args, **kwargs)
Exemple #4
0
 def save(self, *args, **kwargs):
     self.username = generate_random_username()
     self.full_clean()
     super(MyUser, self).save(*args, **kwargs)
     if self._password is not None:
         password_validation.password_changed(self._password, self)
         self._password = None
Exemple #5
0
 def save(self, commit=True):
     password = self.cleaned_data["new_password1"]
     self.user.set_password(password)
     password_validation.password_changed(password, self.user)
     if commit:
         self.user.save()
     return self.user
Exemple #6
0
 def save(self, commit=True):
     password = self.cleaned_data["new_password1"]
     self.user.set_password(password)
     password_validation.password_changed(password, self.user)
     if commit:
         self.user.save()
     return self.user
Exemple #7
0
 def save(self, *args, **kwargs):
     if self.mobile or self.email:
         super().save(*args, **kwargs)
         if self._password is not None:
             password_validation.password_changed(self._password, self)
             self._password = None
     else:
         raise Exception('mobile and email is none')
Exemple #8
0
    def save(self, *args, **kwargs):

        self.check_group()

        super().save(*args, **kwargs)
        if self._password is not None:
            password_validation.password_changed(self._password, self)
            self._password = None
 def validate(self, password, user):
     if user.check_password(password):
         raise ValidationError(
             _("Your password must be different from old password"),
             code='password_no_change',
         )
     else:
         password_changed(password)
Exemple #10
0
 def save(self, *args, **kwargs):
     if not self.pk:
         super().save(*args, **kwargs)
         email, domain = self.email.split('@')
         Profile.objects.create(user=self, username=email)
     else:
         cache.delete(f'user{self.pk}')
         super().save(*args, **kwargs)
     if self._password is not None:
         password_validation.password_changed(self._password, self)
         self._password = None
    def test_password_changed_with_custom_validator(self):
        class Validator:
            def password_changed(self, password, user):
                self.password = password
                self.user = user

        user = object()
        validator = Validator()
        password_changed('password', user=user, password_validators=(validator,))
        self.assertIs(validator.user, user)
        self.assertEqual(validator.password, 'password')
Exemple #12
0
    def save(self, *args, **kwargs):
        # unique_url, access_tokenが存在しない場合は生成
        if len(self.unique_url) == 0:
            self.unique_url = self.generate_unique_url()
        if self.access_token is None:
            self.access_token = self.generate_access_token()

        # 公開期限日が設定されていない場合、回答期限日と同一であると設定
        if self.expired_at and not self.finished_at:
            self.finished_at = self.expired_at
        super().save(*args, **kwargs)
        if self._password is not None:
            password_validation.password_changed(self._password, self)
            self._password = None
Exemple #13
0
 def patch(self, request):
     body = json.loads(request.body)
     user = User.objects.get(id=request.user.id)
     if 'password' in body and request.user.check_password(
             body['password']):
         # should consider validation
         if 'alpaca_key_id' in body:
             user.alpaca_key_id = body['alpaca_key_id']
             if not body['alpaca_key_id'] or len(
                     body['alpaca_key_id']) > 64:
                 return Response(
                     {
                         'alpaca_key_id':
                         "Must not be empty or longer than 64 characters"
                     },
                     status=status.HTTP_400_BAD_REQUEST)
         if 'alpaca_secret_key' in body:
             user.alpaca_secret_key = body['alpaca_secret_key']
             if not body['alpaca_secret_key'] or len(
                     body['alpaca_secret_key']) > 64:
                 return Response(
                     {
                         'alpaca_secret_key':
                         "Must not be empty or longer than 64 characters"
                     },
                     status=status.HTTP_400_BAD_REQUEST)
         if 'new_email' in body:
             try:
                 validate_email(body['new_email'])
                 user.email = body['new_email']
             except Exception as e:
                 return Response({'new_email': e.messages[0]},
                                 status=status.HTTP_400_BAD_REQUEST)
         if 'new_password' in body:
             try:
                 v = validate_password(password=body['new_password'],
                                       user=request.user)
                 user.set_password(str(body['new_password']))
                 password_changed(password=body['new_password'],
                                  user=request.user)
             except Exception as e:
                 return Response({'new_password': e.messages[0]},
                                 status=status.HTTP_400_BAD_REQUEST)
         user.save()
         return Response({'message': 'User data updated successfully.'},
                         status=status.HTTP_200_OK)
     else:
         return Response({'password': '******'},
                         status=status.HTTP_401_UNAUTHORIZED)
Exemple #14
0
    def create(self, validated_data):
        password = validated_data['password']

        try:
            validate_password(password)
        except Exception as e:
            raise ValidationError({'password': e})

        user = get_user_model().objects.create(
            email=validated_data['email'],
            username=validated_data['username'],
        )

        user.set_password(password)
        user.save()
        password_changed(password, user)

        return user
Exemple #15
0
    def post(self, request):
        '''
        处理用户对于```/accounts/change_password```的post请求
        处理用户的修改密码的请求

        @param in POST
            old_password<str>:  旧密码
            new_password<str>:  新密码

        @return in JSON
            code<int>: 返回代码
                       可能值及其含义
                       | 返回值 | 含义               |
                       | ------ | ------------------ |
                       | 200    | 修改密码成功       |
                       | 400    | 旧的密码错误       |
                       | 401    | 未登录             |
                       | 420    | 新的密码不符合要求 |
            msg<dict>:  返回代码相应的解释
        '''
        old_password = request.POST.get('old_password')
        new_password = request.POST.get('new_password')

        try:
            password_changed(new_password, request.user)
        except ValidationError as e:
            return JsonResponse({'code': 420, 'msg': e.messages})
        user = authenticate(request,
                            username=request.user.username,
                            password=old_password)
        if user:
            user.set_password(new_password)
            user.save()
            return JsonResponse({
                'code': 200,
                'msg': [_('Change password successfully')]
            })
        else:
            return JsonResponse({
                'code': 400,
                'msg': [_('The old password is not correct')]
            })
Exemple #16
0
 def save(self, *args, **kwargs):
     if self.get_in_date is None:
         self.get_in_date = datetime.today()
     if self.get_out_date is not None:
         if self.get_out_date > self.get_in_date:
             self.experience = str(
                 (self.get_out_date.year - self.get_in_date.year) * 12 +
                 (self.get_out_date.month -
                  self.get_in_date.month)) + ' мес'
     else:
         if datetime.today().strftime(
                 '%Y-%m-%d') > self.get_in_date.strftime('%Y-%m-%d'):
             self.experience = str(
                 (datetime.today().year - self.get_in_date.year) * 12 +
                 (datetime.today().month - self.get_in_date.month)) + ' мес'
         else:
             self.experience = '0 мес'
     super().save(*args, **kwargs)
     if self._password is not None:
         password_validation.password_changed(self._password, self)
         self._password = None
    def save(self, *args, **kwargs):

        # Custom primary key
        if not self.pk:
            self.pk = generate_short_uuid4()

        # Generate Password and a valid activation token
        if not self.activation_key:
            self.activation_key = generate_activation_token(self)

        if self._password is not None:
            password_changed(self._password, self)
            self._password = None

        # Referral Code Signature
        if not self.referral_code:
            signer = signing.Signer()
            ref = signer.sign(self.pk)

            self.referral_code = ref.split(":")[1]

        return super(AbstractUser, self).save(*args, **kwargs)
 def test_password_changed(self):
     self.assertIsNone(password_changed("password"))
Exemple #19
0
 def save(self, *args, **kwargs):
     super(AbstractBaseUser, self).save(*args, **kwargs)
     if self._password is not None:
         password_validation.password_changed(self._password, self)
         self._password = None
Exemple #20
0
 def save(self, *args, **kwargs):
     super(AbstractBaseUser, self).save(*args, **kwargs)
     if self._password is not None:
         password_validation.password_changed(self._password, self)
         self._password = None
Exemple #21
0
 def save(self, *args, **kwargs):
     super().save(*args, **kwargs)
     if self._otp is not None:
         password_validation.password_changed(self._otp, self)
         self._otp = None
Exemple #22
0
 def test_password_changed(self):
     self.assertIsNone(password_changed("password"))
Exemple #23
0
 def update(self, instance, validated_data):
     """Only change password in PUT method"""
     password_changed(validated_data.password, instance)
     return self.list(instance.pk)
Exemple #24
0
 def save(self, *args, **kwargs):
     if self.password is not None:
         password_validation.password_changed(self.password, self)
         if not self.is_superuser:
             self.set_password(self.password)
         super().save(*args, **kwargs)
Exemple #25
0
 def save(self, *args, **kwargs):
     super(Corporator, self).save(*args, **kwargs)
     if self._password is not None:
         password_validation.password_changed(self._password, self)
         self._password = None
 def test_password_changed(self):
     self.assertIsNone(password_changed('password'))
"""
Exemple #28
0
 def save(self, *args, **kwargs):
     # self.slug = self.slug or slugify(self.username)
     super().save(*args, **kwargs)
     if self._password is not None:
         password_validation.password_changed(self._password, self)
         self._password = None
Exemple #29
0
=======
>>>>>>> 37c99181c9a6b95433d60f8c8ef9af5731096435
    def __str__(self):
        return self.get_username()

    def clean(self):
        setattr(self, self.USERNAME_FIELD, self.normalize_username(self.get_username()))

    def save(self, *args, **kwargs):
<<<<<<< HEAD
        super(AbstractBaseUser, self).save(*args, **kwargs)
=======
        super().save(*args, **kwargs)
>>>>>>> 37c99181c9a6b95433d60f8c8ef9af5731096435
        if self._password is not None:
            password_validation.password_changed(self._password, self)
            self._password = None

    def natural_key(self):
        return (self.get_username(),)

    @property
    def is_anonymous(self):
        """
        Always return False. This is a way of comparing User objects to
        anonymous users.
        """
<<<<<<< HEAD
        return CallableFalse
=======
        return False