def render(self, name, value, attrs):
original = ReadOnlyPasswordHashField.widget().render(name, value, attrs)
if 'Invalid' not in original:
return original
encoded = value
if not encoded:
summary = mark_safe("<strong>%s</strong>" % _("No password set."))
else:
size = len(value)
summary = value[:int(size/2)] + '*'*int(size-size/2)
summary = "<strong>hash</strong>: %s" % summary
if value.startswith('*'):
summary = "<strong>algorithm</strong>: sha1_bin_hex %s" % summary
return format_html("<div>%s</div>" % summary)
class UserChangeForm(forms.ModelForm):
password = ReadOnlyPasswordHashField()
class Meta:
model = User
fields = (
"email",
"password",
"firstname",
"lastname",
"profile_photo",
"description",
"website",
"following",
"is_superuser",
)
def clean_password(self):
return self.initial["password"]
class UserChangeForm(forms.ModelForm):
"""
A form for updating users. Includes all the fields on
the user, but replaces the password field with admin's
password hash display field.
"""
password = ReadOnlyPasswordHashField()
class Meta:
model = User
fields = ('email', 'password', 'is_active', 'is_staff')
def clean_password(self):
"""
Regardless of what the user provides, return the initial value.
This is done here, rather than on the field, because the
field does not have access to the initial value
"""
return self.initial["password"]
class UserAdminChangeForm(forms.ModelForm):
password = ReadOnlyPasswordHashField()
class Meta:
model = User
fields = (
'email',
'password',
'first_name',
'last_name',
'active',
'admin',
)
def clean_password(self):
# Regardless of what the user provides, return the initial value.
# This is done here, rather than on the field, because the
# field does not have access to the initial value
return self.initial["password"]
class UserChangeForm(forms.ModelForm):
password = ReadOnlyPasswordHashField(label=_('Password'), help_text=_(
'Raw passwords are not stored, so there is no way to see '
'this user\'s password, but you can change the password '
'using <a href=\"password/\">this form</a>.'))
class Meta:
model = get_user_model()
exclude = ()
def __init__(self, *args, **kwargs):
super(UserChangeForm, self).__init__(*args, **kwargs)
f = self.fields.get('user_permissions', None)
if f is not None:
f.queryset = f.queryset.select_related('content_type')
def clean_password(self):
return self.initial['password']
class UserChangeForm(BaseUserChangeForm):
password = ReadOnlyPasswordHashField(
label=_("Password"),
help_text=_(
"Raw passwords are not stored, so there is no way to see this "
"user's password, but you can change the password using "
"<a href=\"{}\">this form</a>."
),
)
class Meta:
model = User
fields = '__all__'
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def clean_password(self):
return self.initial['password']
class UserChangeForm(forms.ModelForm):
#只读的哈希字段
password = ReadOnlyPasswordHashField(label=_('密码'))
class Meta:
model = get_user_model()
exclude = ()
def __init__(self, *args, **kwargs):
super(UserChangeForm, self).__init__(*args, **kwargs) #父对象初始化
f = self.fields.get('user_permissions', None)
if f is not None:
f.queryset = f.queryset.select_related('content_type')
def clean_password(self):
try:
return self.initial['password']
except KeyError:
pass
class UserChangeForm(forms.ModelForm):
"""A form for updating users. Includes all the fields on
the user, but replaces the password field with admin's
password hash display field.
"""
password = ReadOnlyPasswordHashField(
label=("Password"),
help_text=('<a href="../password/">Change Password</a>.'))
class Meta:
model = CustomUser
fields = ('email', 'password', 'first_name', 'last_name', 'is_active',
'is_staff')
def clean_password(self):
# Regardless of what the user provides, return the initial value.
# This is done here, rather than on the field, because the
# field does not have access to the initial value
return self.initial["password"]
class PersonForm(forms.ModelForm):
password = ReadOnlyPasswordHashField()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["password"].help_text = (
"Raw passwords are not stored, so there is no way to see "
"this user's password."
)
def clean_password(self):
# Regardless of what the user provides, return the initial value.
# This is done here, rather than on the field, because the
# field does not have access to the initial value
return self.initial["password"]
class Meta:
model = Person
fields = "__all__"
class UserChangeForm(forms.ModelForm):
"""
A form for updating users. Includes all the fields on
the user, but replaces the password field with admin's
password hash display field.
"""
password = ReadOnlyPasswordHashField(
label=_("Password"), widget=BetterReadOnlyPasswordHashWidget)
class Meta:
model = User
if DJANGO_VERSION >= (1, 6):
fields = '__all__'
def clean_password(self):
# Regardless of what the user provides, return the initial value.
# This is done here, rather than on the field, because the
# field does not have access to the initial value
return self.initial["password"]
class AuPairUserChangeForm(forms.ModelForm):
password = ReadOnlyPasswordHashField()
class Meta:
model = AuPairUser
fields = (
'username',
'email',
'password',
'first_name',
'last_name',
'agency',
'active',
'admin',
'staff',
)
def clean_password(self):
return self.initial['password']
class FUtilisateurUpdate(forms.ModelForm):
# Import
from django.contrib.auth.forms import ReadOnlyPasswordHashField
# Champ
password = ReadOnlyPasswordHashField(help_text='''
Les mots de passe ne sont pas enregistrés en clair, ce qui ne permet pas d'afficher le mot de passe de cet
utilisateur, mais il est possible de le changer en utilisant <a href="../password/">ce formulaire</a>.
''',
label='Mot de passe')
class Meta:
fields = [
'email', 'first_name', 'is_active', 'is_staff', 'is_superuser',
'last_name', 'username'
]
labels = {'email': 'Courriel principal', 'last_name': 'Nom de famille'}
model = TUtilisateur
def __init__(self, *args, **kwargs):
super(FUtilisateurUpdate, self).__init__(*args, **kwargs)
# Passage de certains champs à l'état requis
self.fields['email'].required = True
self.fields['first_name'].required = True
self.fields['last_name'].required = True
def clean_password(self):
return self.initial['password']
def save(self, *args, **kwargs):
# Modification d'une instance TUtilisateur
obj = super(FUtilisateurUpdate, self).save(*args, **kwargs).save()
# Liaison obligatoire avec la table t_roles_utilisateur
if 'A' not in obj.get_type_util__list():
TRolesUtilisateur.objects.create(
code_type_util=TTypeUtilisateur.objects.get(pk='A'),
id_util=obj)
return obj
class MedicoChangeForm(UserChangeForm):
crm = forms.CharField(
min_length=5, widget=forms.TextInput(attrs={'readonly': 'readonly'}))
email = forms.CharField(min_length=6)
first_name = forms.CharField(min_length=6)
last_name = forms.CharField(min_length=6)
password = forms.CharField()
date_joined = forms.DateTimeField()
#occupation = forms.ChoiceField()
avatar = forms.ImageField(required=False, widget=forms.FileInput())
password = ReadOnlyPasswordHashField()
class Meta:
model = Medico
fields = [
'crm', 'email', 'first_name', 'last_name', 'date_joined',
'occupation', 'avatar'
]
class UserChangeForm(forms.ModelForm):
"""
A form for updating users. Includes all the fields on
the user, but replaces the password field with admin's
password hash display field.
"""
password = ReadOnlyPasswordHashField()
class Meta:
model = User
fields = ('email', 'first_name', 'last_name', 'citizenship', 'address',
'city', 'province', 'postal', 'country', 'is_active',
'is_admin')
def clean_password(self):
# Regardless of what the user provides, return the initial value.
# This is done here, rather than on the field, because the
# field does not have access to the initial value
return self.initial["password"]
class UserChangeForm(forms.ModelForm):
"""A form for updating users. Includes all the fields on
the user, but replaces the password field with admin's
password hash display field.
"""
password = ReadOnlyPasswordHashField(label="Password",
help_text=("Raw passwords are not stored, so there is no way to see "
"this user's password, but you can change the password "
"using <a href=\"password/\">this form</a>."))
class Meta:
model = UserProfile
fields = ('email', 'password','is_active', 'is_admin')
def clean_password(self):
# Regardless of what the user provides, return the initial value.
# This is done here, rather than on the field, because the
# field does not have access to the initial value
return self.initial["password"]
class UserChangeForm(forms.ModelForm):
"""A form for updating users. Includes all the fields on
the user, but replaces the password field with admin's
password hash display field.
"""
password = ReadOnlyPasswordHashField()
password1 = forms.CharField(label='Password',
widget=forms.PasswordInput,
required=False)
password2 = forms.CharField(label='Password confirmation',
widget=forms.PasswordInput,
required=False)
class Meta:
model = User
fields = ('email', 'password', 'first_name', 'last_name',
'date_joined', 'is_superuser', 'is_admin', 'phone')
def clean_password(self):
# Regardless of what the user provides, return the initial value.
# This is done here, rather than on the field, because the
# field does not have access to the initial value
return self.initial["password"]
def clean_password2(self):
# Check that the two password entries match
password1 = self.cleaned_data.get("password1")
password2 = self.cleaned_data.get("password2")
if not password1 and not password2:
return None
if password1 and password2 and password1 != password2:
raise forms.ValidationError("Passwords don't match")
return password2
def save(self, commit=True):
# Save the provided password in hashed format
user = super().save(commit=False)
if self.cleaned_data['password2']:
user.set_password(self.cleaned_data["password1"])
if commit:
user.save()
return user
class UserChangeForm(forms.ModelForm):
username = forms.RegexField(
label=_("Username"),
max_length=75,
regex=r"^[\w.@+-]+$",
help_text=
_("Required. 75 characters or fewer. Letters, digits and @/./+/-/_ only"
),
error_message=_(
"This value must contain only letters, digits and @/./+/-/_."))
password = ReadOnlyPasswordHashField(
label=_("Password"),
help_text=_("Raw passwords are not stored, so there is no way to see "
"this user's password, but you can change the password "
"using <a href=\"password/\">this form</a>."))
noc_user_permissions = forms.CharField(label="User Access",
widget=AccessWidget,
required=False)
class Meta:
model = User
def __init__(self, *args, **kwargs):
super(UserChangeForm, self).__init__(*args, **kwargs)
if "instance" in kwargs:
self.initial[
"noc_user_permissions"] = "user:"******"username"]
self.new_perms = set()
if args:
self.new_perms = set(
[p[5:] for p in args[0] if p.startswith("perm_")])
def clean_password(self):
return self.initial["password"]
def save(self, commit=True):
model = super(UserChangeForm, self).save(commit)
model.is_staff = True
#if not model.id:
model.save()
Permission.set_user_permissions(model, self.new_perms)
return model
class BoxmeUserChangeForm(forms.ModelForm):
"""
A form for updating users.
Includes all the fields on the user, but replaces the password field
with admin's password hash display field.
"""
# In Django 1.9 the url for changing the password was changed (#15779)
# A url name was also added in 1.9 (same issue #15779),
# so reversing the url is not possible for Django < 1.9
password = ReadOnlyPasswordHashField(
label=_("Password"),
help_text=_("Raw passwords are not stored, so there is no way to see "
"this user's password, but you can change the password "
"using <a href=\"%(url)s\">this form</a>.") %
{'url': 'password/' if django.VERSION < (1, 9) else '../password/'})
class Meta: # noqa: D101
model = get_user_model()
exclude = ()
def __init__(self, *args, **kwargs):
"""Init the form."""
super(BoxmeUserChangeForm, self).__init__(*args, **kwargs)
f = self.fields.get('user_permissions', None)
if f is not None:
f.queryset = f.queryset.select_related('content_type')
def clean_password(self):
"""
Clean password.
Regardless of what the user provides, return the initial value.
This is done here, rather than on the field, because the
field does not have access to the initial value.
:return str password:
"""
return self.initial["password"]
class UserChangeForm(CleanNamesForm):
'''A form for updating users. Includes all the fields on
the user, but replaces the password field with admin's
password hash display field.
'''
password = ReadOnlyPasswordHashField(
help_text=_('Raw passwords are not stored, so there is no way to see '
'this user\'s password, but you can change the password '
'using <a href=\'password/\'>this form</a>.'))
class Meta:
model = MyUser
fields = '__all__'
def clean_password(self):
# Regardless of what the user provides, return the initial value.
# This is done here, rather than on the field, because the
# field does not have access to the initial value.
return self.initial['password']
class PostUserChangeForm(forms.ModelForm):
email = forms.EmailField(label=_("Email"))
password = ReadOnlyPasswordHashField(
label=_("Password"),
help_text=_("Raw passwords are not stored, so there is no way to see "
"this user's password, but you can change the password "
"using <a href=\"password/\">this form</a>."))
class Meta:
model = PostUser
fields = '__all__'
def __init__(self, *args, **kwargs):
super(PostUserChangeForm, self).__init__(*args, **kwargs)
f = self.fields.get('user_permissions', None)
if f is not None:
f.queryset = f.queryset.select_related('content_type')
def clean_password(self):
return self.initial["password"]
class UserAdminChangeForm(forms.ModelForm):
password = ReadOnlyPasswordHashField()
class Meta:
fields = ('password', 'username', 'first_name', 'last_name',
'is_active', 'is_staff', 'is_admin')
username = forms.RegexField(
regex=r'^[\w._-]+$',
label='Pseudonyme',
min_length=3,
error_messages={
'invalid':
"Votre ne pseudonyme ne peut contenir que des lettres,"
"nombres ou caractères suivants : ./_/-"
},
widget=TextInput(attrs={'class': 'form-control'}))
def clean_password(self):
return self.initial["password"]
class UserChangeForm(forms.ModelForm):
password = ReadOnlyPasswordHashField(
label=_('Password'),
help_text=_(u'密码经过加密，因此不可见 ,'
u'但是使用 <a href=\"/accounts/password_change/\">这个</a>'
u'链接可以修改密码.'))
class Meta:
model = get_user_model()
exclude = ()
def __init__(self, *args, **kwargs):
super(UserChangeForm, self).__init__(*args, **kwargs)
f = self.fields.get('user_permissions', None)
if f is not None:
f.queryset = f.queryset.select_related('content_type')
def clean_password(self):
return self.initial['password']
class UserChangeForm(forms.ModelForm):
# 사용자 변경 폼
email = forms.EmailField(
label=_('이메일'),
disabled=True,
)
password = ReadOnlyPasswordHashField(label=_('비밀번호'))
profile_img = forms.ImageField(label=_('프로필 이미지'))
class Meta:
model = User
fields = ('email', 'password', 'profile_img', 'is_active', 'is_admin')
def clean_password(self):
# Regardless of what the user provides, return the initial value.
# This is done here, rather than on the field, because the
# field does not have access to the initial value
return self.initial["password"]
class UserAdminChangeForm(forms.ModelForm):
password = ReadOnlyPasswordHashField()
class Meta:
model = Users
fields = [
'email',
'password',
'first_name',
'last_name',
'cedula',
'licencia',
'active',
'admin'
]
def clean_password(self):
return self.initial['password']
class PersonnelChangeForm(forms.ModelForm):
"""
A form for updating users. Includes all the fields on
the user, but replaces the password field with admin's
password hash display field.
"""
password = ReadOnlyPasswordHashField()
class Meta:
model = Personnel
fields = ('email', 'first_name', 'last_name', 'sex', 'date_of_birth',
'address', 'qualification', 'is_doctor', 'is_active',
'is_admin')
def clean_password(self):
# Regardless of what the user provides, return the initial value.
# This is done here, rather than on the field, because the
# field does not have access to the initial value
return self.initial["password"]
class UserChangeForm(UserFormMixin, forms.ModelForm):
"""A form for updating users. Includes all the fields on
the user, but replaces the password field with admin's
password hash display field.
"""
password = ReadOnlyPasswordHashField(label=_("Password"),
help_text=_("Raw passwords are not stored, so there is no way to see "
"this user's password, but you can change the password "
"using <a href=\"../password/\">this form</a>."))
last_name = forms.CharField(label='Last name', required=False)
class Meta:
model = BaseCustomUser
exclude = ('id',)
def clean_password(self):
# Regardless of what the user provides, return the initial value.
# This is done here, rather than on the field, because the
# field does not have access to the initial value
return self.initial["password"]
class UserChangeForm(forms.ModelForm):
"""A form for updating users. Includes all the fields on
the user, but replaces the password field with admin's
password hash display field.
"""
password = ReadOnlyPasswordHashField(
label=("Password"),
help_text=(
"Passwords are not stored in plaintext, so there is no way to see "
"this user's password"))
class Meta:
model = User
exclude = []
def clean_password(self):
# Regardless of what the user provides, return the initial value.
# This is done here, rather than on the field, because the
# field does not have access to the initial value
return self.initial["password"]
class UserChangeForm(forms.ModelForm):
password = ReadOnlyPasswordHashField(
label=("Senha"),
help_text=(
"Esta é a senha criptografada do usuário, mas você pode alterar "
'acessando <a href="../password/">este formulário</a>.'
),
)
def __init__(self, *args, **kwargs):
super(UserChangeForm, self).__init__(*args, **kwargs)
self.fields["groups"].required = True
class Meta:
model = User
fields = "__all__"
def clean_password(self):
return self.initial["password"]
class UserChangeForm(forms.ModelForm):
"""A form for updating users. Includes all the fields on
the user, but replaces the password field with admin's
password hash display field.
"""
password = ReadOnlyPasswordHashField()
class Meta:
model = CustomUser
fields = (
'email',
'password',
'contact_number',
'employee_id',
'name',
)
def clean_password(self):
return self.initial["password"]
class UserChangeForm(forms.ModelForm):
"""A form for updating users. Includes all the fields on
the user, but replaces the password field with admin's
password hash display field.
"""
password = ReadOnlyPasswordHashField()
class Meta:
model = User
widgets = {
'groups': FilteredSelectMultiple('groups', 1),
}
fields = ('name', 'mobile', 'district', 'password', 'available_date',
'score', 'avatar', 'is_active', 'is_admin')
def clean_password(self):
# Regardless of what the user provides, return the initial value.
# This is done here, rather than on the field, because the
# field does not have access to the initial value
return self.initial["password"]
class MemberChangeForm(forms.ModelForm):
"""
A form for updating member info. Includes all the fields
on the member, but replaces the password field with
admin"s password hash display field.
"""
class Meta:
model = Member
password = ReadOnlyPasswordHashField(
help_text=("Raw passwords are not stored, so there is no way to see "
"this user's password, but you can change the password "
"using <a href=\"password/\">this form</a>."))
def clean_password(self):
# Regardless of what the user provides, return the
# initial value. This is done here, rather than on
# the field, because the field does not have access
# to the initial value
return self.initial["password"]
def test_readonly_field_has_changed(self):
field = ReadOnlyPasswordHashField()
self.assertFalse(field.has_changed('aaa', 'bbb'))
def test_readonly_field_has_changed(self):
field = ReadOnlyPasswordHashField()
self.assertFalse(field._has_changed("aaa", "bbb"))
