def post(self, request):
# 接收参数
data = request.POST
form = PasswordModelForm(data)
# 验证数据的合法性
if form.is_valid():
# 获取清洗后的数据
cleaned = form.cleaned_data
# 取出清洗后的密码
# 将密码进行加密
password = set_password(cleaned.get('password'))
# 通过id查询数据
user_id = request.session.get('ID')
# print(user_id)
# 修改到数据库
# 验证原密码是否存在,不能用get,用filter
if Users.objects.filter(id=user_id, password=password).exists():
newpassword = set_password(cleaned.get('newpassword'))
# 更新密码
Users.objects.filter(id=user_id).update(password=newpassword)
# 跳转到登录页
return redirect('user:登录')
else:
# 提示错误
return render(request, 'user/password.html', {'form': form})
def post(self, request):
# 接收参数
data = request.POST
# 验证参数合法性 表单验证
form = ForgetpasswordModelForm(data)
if form.is_valid():
# 获取清洗后的数据
cleaned = form.cleaned_data
# 将密码进行加密
# 通过id查询数据
user_id = request.session.get('ID')
# 取出清洗后的手机号
phone = cleaned.get('phone')
# 取出清洗后的密码
newpassword= set_password(cleaned.get('newpassword'))
# 修改到数据库
# 验证原密码是否存在,不能用get,用filter
if Users.objects.filter(phone=phone, id=user_id).exists():
# 更新密码
Users.objects.filter(id=user_id).update(password=newpassword)
# 跳转到登录页
return redirect('user:登录')
else:
return render(request, 'user/forgetpassword.html', context={'form': form})
def reg(request):
"""
用户注册,
获取数据
解析数据
返回响应
:param request:
:return:
"""
if request.method == 'POST': # 判断是从什么条件下进入网页,如果是POST,则是提交的方式
data = request.POST # 获取提交内容
form = AccountVerify(data) # 解析提交内容
if form.is_valid(): # 对获取清除后的数据判断
data = form.cleaned_data
password_one = data['password2']
password = set_password(password_one)
Username.objects.create(username=data['account'], password=password) # 存入数据库
return redirect("user:登录")
else:
context = {
'errors': form.errors, # 生成错误提示
'data': data, # 回显数据
}
# print(data.get('account'))
return render(request, "personal/reg.html", context) # 提交到页面
else:
return render(request, 'personal/reg.html')
def clean(self):
# 验证用户名
phone = self.cleaned_data.get('phone')
try:
user = Users.objects.get(phone=phone)
except Users.DoesNotExist:
raise forms.ValidationError({'phone': '手机号错误'})
password = self.cleaned_data.get('password', '')
if user.password != set_password(password): # 初始化加密密码
raise forms.ValidationError({'password': '******'})
self.cleaned_data['user'] = user # seesion返回整条记录
return self.cleaned_data
# 综合校验
# 验证 用户传入的验证码和redis中的是否一样
# 用户传入的
try:
captcha = self.cleaned_data.get('captcha')
phone = self.cleaned_data.get('phone', '')
# 获取redis中的
r = get_redis_connection()
random_code = r.get(phone) # 二进制, 转码
random_code = random_code.decode('utf-8')
# 比对
if captcha and captcha != random_code:
raise forms.ValidationError({"captcha": "验证码输入错误!"})
except:
raise forms.ValidationError({"captcha": "验证码输入错误!"})
# 返回清洗后的所有数据
return self.cleaned_data
def clean(self):
data = super(RegisterForm, self).clean()
pwd1 = data.get("pwd") # 输入密码
pwd2 = data.get("password") # 验证密码
if pwd1 and pwd2 and pwd1 != pwd2:
raise forms.ValidationError({"password": "******"})
else:
if pwd1:
data["pwd"] = set_password(pwd1)
return data
def clean(self):
phone = self.cleaned_data.get('phone')
password = self.cleaned_data.get('password')
try:
user = MarketUsers.objects.get(phone=phone)
except MarketUsers.DoesNotExist:
raise forms.ValidationError({'phone': '手机号码错误'})
if user.password != set_password(password):
raise forms.ValidationError({'password': '******'})
self.cleaned_data['user'] = user
return self.cleaned_data
def clean(self):
# 所有清洗后的数据
clean_data = super().clean()
pwd1 = clean_data.get('password')
pwd2 = clean_data.get('repassword')
if pwd1 and pwd2 and pwd1 != pwd2:
raise forms.ValidationError({"repassword": '******'})
else:
# 密码一致，则对密码进行加密
clean_data['password'] = set_password(pwd1)
# 返回清洗后的数据
return clean_data
def clean(self):
data = self.cleaned_data
phone = data.get("phone")
password = data.get("password")
password = set_password(password)
num = User.objects.filter(phone=phone).first()
if not num:
raise forms.ValidationError({"phone": "请填写正确的账户和密码"})
elif password != num.password:
raise forms.ValidationError({"password": "******"})
else:
return data
def clean(self):
# 验证两次密码是否一致
# 获取数据
cleaned_data = super().clean()
password1 = self.cleaned_data.get("password1")
password2 = self.cleaned_data.get("password2")
if password1 and password2 and password1 != password2:
raise forms.ValidationError({"password2": "两次密码不一致"})
else:
# 两次密码验证一致,对密码进行加密
if password1:
cleaned_data['password1'] = set_password(password1)
return cleaned_data
def clean(self):
# 验证用户名
user_phone = self.cleaned_data.get("user_phone")
password = self.cleaned_data.get('password')
# 到数据库去查询
try:
user = User.objects.get(user_phone=user_phone)
except User.DoesNotExist:
raise forms.ValidationError({"user_phone": "号码错误"})
# 验证密码
if user.user_password != set_password(password):
raise forms.ValidationError({"password": "******"})
self.cleaned_data['user'] = user
return self.cleaned_data
def clean(self):
old_password = self.cleaned_data.get('old_password')
old_password = set_password(old_password)
try:
old_password == SpUser.objects.filter(password=old_password)
except SpUser.DoesNotExist:
raise forms.ValidationError({"old_password": '******'})
pwd1 = self.cleaned_data.get('password')
pwd2 = self.cleaned_data.get('re_password')
if pwd1 and pwd2 and pwd1 != pwd2:
# 确认密码错误
raise forms.ValidationError({"re_password": "******"})
return self.cleaned_data
def post(self, request):
# 完成用户信息的注册
# 接收参数
data = request.POST
# 验证参数合法性 表单验证
form = RegisterModelForm(data)
if form.is_valid():
# 获取清洗后的数据
cleaned_data = form.cleaned_data
# 保存数据库
user = Users()
user.phone = cleaned_data.get('phone')
user.password = set_password(cleaned_data.get('password'))
user.save()
return redirect('user:登录')
else:
return render(request, 'user/reg.html', context={'form': form})
def clean(self):
#清洗数据,增加用户体验
cleaned_data = super().clean()
telephone = cleaned_data.get("telephone")
password = cleaned_data.get("password")
if all([telephone, password]): #如果账号密码存在
try:
user = UserInfo.objects.get(
telephone=telephone) #得到用户,根据用户找到密码
except UserInfo.DoesNotExist:
raise ValidationError({"telephone": "用户不存在"})
if user.password != set_password(password):
raise ValidationError({"password": "******"})
#将用户信息保存到clean_data中
cleaned_data['user'] = user
return cleaned_data
return cleaned_data
def post(self, request):
# 接收参数
data = request.POST
# 验证数据合法性
register_form = RegModelForm(data)
if register_form.is_valid():
# 操作数据库
# 获取清洗后的数据
cleand_data = register_form.cleaned_data
# 保存
user = MarketUsers()
user.phone = cleand_data.get('phone')
user.password = set_password(cleand_data.get('password'))
user.save()
return redirect('user:登录')
else:
return render(request, 'user/reg.html', {"form": register_form})
def clean(self):
# 验证手机号和密码是否正确
# 获取用户输入的信息
cleaned_data = super(LoginForm, self).clean()
phone = cleaned_data.get("phone")
password = cleaned_data.get("password")
# 根据输入的信息查询数据库
user = User.objects.filter(phone=phone).first()
if user is None:
raise forms.ValidationError({"phone": "该用户没有注册"})
else:
password_in_db = user.password
password = set_password(password)
if password_in_db == password:
cleaned_data["user"] = user
return cleaned_data
else:
raise forms.ValidationError({"password": "******"})
def post(self,request):
data = request.POST
reg_form = RegisterForm(data)
if reg_form.is_valid():
#合法
data = reg_form.cleaned_data
#获取密码 加密
password = data.get("password1")
password = set_password(password)
#添加到数据库
UserInfo.objects.create(telephone=data.get("telephone"),password=password)
#返回到登录页
return redirect("user:login")
else:
context ={
"errors":reg_form.errors
}
return render(request,"user/reg.html",context)
def clean(self):
# 验证手机号和密码
# 获取手机号和密码
phone = self.cleaned_data.get('phone')
password = self.cleaned_data.get('password')
# 验证
try:
user = SpUser.objects.get(phone=phone)
except SpUser.DoesNotExist:
raise forms.ValidationError({"phone": '该手机号码未注册'})
# 验证密码
if user.password != set_password(password):
# 确认密码错误
raise forms.ValidationError({"password": "******"})
# 将用户信息保存到cleaned_data中
self.cleaned_data['user'] = user
return self.cleaned_data
def post(self, request):
#接收参数
data = request.POST
#实例化form表单对象
form = RegisterModelForm(data)
#验证数据合法性
if form.is_valid():
#合法
#获取清洁后数据
cleaned_data = form.cleaned_data
#创建一个用户
user = SpUsers()
user.tel = cleaned_data.get('tel')
user.password = set_password(cleaned_data.get('repassword'))
user.save()
return redirect('user:登录')
else:
return render(request, 'user/reg.html', {'form': form})
def clean(self):
clean_data = super().clean()
# 获取用户输入的数据
phone = clean_data.get('mobile')
pwds = clean_data.get('password', '')
# 通过手机号码查询数据，如果存在再验证密码 ，如果不存在则直接报错
user = Usermodel.objects.filter(mobile=phone).first()
if user is None:
raise forms.ValidationError({"mobile": "该手机号码没有注册！"}) # mobile 这个是数据库中的字段
else:
# 手机号码存在，验证密码是否正解
password_in_db = user.password # 数据库中已加密的密码
passwd = set_password(pwds)
if password_in_db != passwd:
raise forms.ValidationError({"password": "******"})
else:
# 密码验证成功，返回clean_data 并顺便将上面查询出来的user对象带回到login view中
clean_data['user'] = user
return clean_data
def clean(self):
# 获取用户名和密码
phone = self.cleaned_data.get('phone')
password = self.cleaned_data.get('password')
# 验证
# 根据手机号码获取
try:
user = Register.objects.get(phone=phone)
except Register.DoesNotExist:
raise forms.ValidationError({'phone': '手机号错误'})
# 验证密码
if user.password != set_password(password):
raise forms.ValidationError({'password': '******'})
# 将用户信息保存到cleaned_data中
self.cleaned_data['user'] = user
return self.cleaned_data
def clean(self):
# 获取用户名和密码
tel = self.cleaned_data.get('tel')
password = self.cleaned_data.get('password')
# 验证
# 根据手机号码获取
try:
user = SpUsers.objects.get(tel=tel)
except SpUsers.DoesNotExist:
raise forms.ValidationError({'tel': '手机号错误'})
# 验证密码
if user.password != set_password(password):
raise forms.ValidationError({'password': '******'})
# 将用户信息保存到cleaned_data中
self.cleaned_data['user'] = user
return self.cleaned_data
def post(self, request):
# 接收参数
data = request.POST
# 验证参数的合法性
register_form = RegisterModelForm(data)
if register_form.is_valid():
# 操作数据库
# 获取清洗后的数据
cleaned_data = register_form.cleaned_data
# 保存到数据库
user = SpUser()
user.phone = cleaned_data.get('phone')
user.password = set_password(cleaned_data.get('password'))
user.save()
# 跳转到登录页面
return redirect('user:登录')
# 合成响应
else:
return render(request, 'user/reg.html', {'form': register_form})
def revise(request):
if request.method == 'GET':
return render(request, 'user/password.html')
else:
data = request.POST
form = ReviseModelForm(data)
if form.is_valid():
# 获取清洗后的数据
cleaned_data = form.cleaned_data
phone = cleaned_data.get('phone')
password = set_password(cleaned_data.get('pwd1'))
# 保存到数据库
Register.objects.filter(phone=phone).update(password=password)
# 合成html
# 自动跳转到登录页面
return redirect('user:登录')
else:
context = {'errors': form.errors}
return render(request, 'user/password.html', context=context)
def post(self,request):
#获取form对象
data = request.POST
for_form = UploadPassword(data)
if for_form.is_valid():
data = for_form.cleaned_data
#获取密码
pwd1 = data.get("password1")
tel = data.get("telephone")
#加密
password = set_password(pwd1)
#修改密码
UserInfo.objects.create(telephone=tel,password=password)
#返回到登录页
return redirect("user:login")
else:
context = {
"errors": for_form.errors
}
return render(request,"user/forgetpassword.html",context)
def login(request):
"""
用户登录,
获取数据
解析数据
返回响应
:param request:
:return:
"""
if request.method == 'POST':
# 接收数据
data = request.POST
form = RegisterLogin(data)
if form.is_valid():
# 接收清除后的数据
data = form.cleaned_data
password_one = data['password']
password = set_password(password_one)
one = Username.objects.filter(username=data['account']).first()
# 判断保存密码是否相同
if one.password == password:
set_session(request, one)
# 判断是从哪里跳转过来的
next = request.GET.get("next")
if next:
return redirect(next)
else:
return redirect("com:首页")
else:
context = {
'errors': '密码错误'
}
return render(request, 'personal/login.html', context)
else:
context = {
'errors': form.errors,
'data': data,
}
return render(request, 'personal/login.html', context)
else:
return render(request, 'personal/login.html')
def clean(self):
# 获取所有清洗后的数据
clean_data = super(LoginForm, self).clean()
# 获取得到的数据
mobile = clean_data.get("mobile")
pwd = clean_data.get("pwd")
# 通过mobile验证,如果成功,验证密码
data = Person.objects.filter(mobile=mobile).first()
if data is None:
# 不存在手机号
raise forms.ValidationError({"mobile": "该手机号还未注册"})
else:
# 存在手机号,验证密码
if set_password(pwd) == data.pwd:
clean_data["data"] = data
return clean_data
else:
raise forms.ValidationError({"pwd": "密码错误"})
def post(self, request):
# 1.接受参数
data = request.POST
# 2.验证参数的合法性
# >>>>1.创建一个form表单验证的对象,来进行数据合法性的验证
form = ResetPassWordForm(data)
if form.is_valid():
# 在数据合法的情况下执行
# 接受清洗后的数据
# 1.<<<< 接收手机号码
phone = form.cleaned_data.get("phone")
# 2.<<<< 接收密码
password = form.cleaned_data.get("password")
# 3.将密码加密
password = set_password(password)
# 将接受的数据,保存到数据当中
UserModel.objects.filter(phone=phone).update(password=password)
# 保存到数据库成功
return redirect("user:用户登录")
else:
# 在数据不合法的情况下
return render(request, 'user/resetpassword.html', {"form": form})
def clean(self):
# >>>>>1.先后去用户传过来的电话号码
phone = self.cleaned_data.get('phone')
# >>>>>2.先到数据库中查看是否有该手机号码
try:
user = UserModel.objects.get(phone=phone)
except UserModel.DoesNotExist:
raise forms.ValidationError(
{"phone": "该手机号码未注册,请输入已经注册手机号码!或者前往注册页面注册!"})
# >>>>>3.在手机号码合法的情况下, 验证密码的合法性
password = self.cleaned_data.get('password')
# 将用户传过来的密码进行加密处理,才能和数据库中的数据进行判断
password = set_password(password)
if user.password != password:
# 在密码不正确的情况下
raise forms.ValidationError("密码错误!")
else:
# 在密码正确的情况下
# 1.<<< 先将查询到的用户信息保存到session之中
self.cleaned_data["user"] = user
# 2.<<< 再将清洗后的数据返回
return self.cleaned_data
def clean(self): # 校验数据
clean_data = self.cleaned_data
# 获取数据
phone = clean_data.get('phone')
password = clean_data.get('password')
# 如果数据合法 对数据进行比对
if all([phone, password]):
try:
# 根据手机号获取用户
user = User.objects.get(phone=phone)
except User.DoesNotExist:
raise forms.ValidationError({'phone': '用户不存在,请仔细核对帐号'})
# 判断密码是否正确
if user.password != set_password(password):
raise forms.ValidationError({'password': '******'})
# 正确 返回 user信息为了登陆是保存在session中提供数据,不用格外再取
clean_data['user'] = user # 吧获取的user信息保存在清洗后的数据中
return user
else:
return clean_data
def post(self, request):
# 接收数据
data = request.POST
# 验证数据合法性
forgetpwd_form = ForgetpwdModelForm(data)
if forgetpwd_form.is_valid():
# 操作数据库
# 更新密码到数据库
cleaned_data = forgetpwd_form.cleaned_data
# 保存到数据库
phone = cleaned_data.get('phone')
password = set_password(cleaned_data.get('password'))
# 修改密码保存到数据库
user = SpUser.objects.get(phone=phone)
user.password = password
user.save()
# 跳转到登录
return redirect('user:登录')
# 合成响应
context = {'form': forgetpwd_form}
return render(request, 'user/forgetpassword.html', context=context)
