def register_handle(request):
"""注册处理"""
# 获取数据
username = request.POST.get('user_name')
password = request.POST.get('pwd')
email = request.POST.get('email')
# 进行数据校验,调用python的内置函数all()
if not all([username, password, email]):
# 若数据为空
return render(request, 'df_user/register.html', {'errmsg': '参数不能为空!'})
# 判断邮箱是否合法
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
# 邮箱不合法
return render(request, 'df_user/register.html', {'errmsg': '邮箱不合法!'})
# 注册
passport = Passport.objects.add_one_passport(username, password, email)
# 验证邮箱,send_mail是io阻塞，所以此处不采用，而使用异步神器celery
# send_mail('天天生鲜邮箱验证','',settings.EMAIL_FROM,[email],html_message='<a href="http://www.baidu.com">百度</a>')
# 生成token
serializer = Serializer(settings.SECRET_KEY, 3600)
token = serializer.dumps({'confirm': passport.id})
token = token.decode()
# 将任务发送到celery的broker那，
send_active_email.delay(token, username, email)
return redirect(reverse('goods:index'))
def post(self, request):
"""
对注册页面发送过来的form表单数据进行处理
:return:
"""
# 获取post请求参数
username = request.POST.get('username')
password = request.POST.get('password')
password2 = request.POST.get('password2')
uphone = request.POST.get('mobile')
code = request.POST.get('code')
email = request.POST.get('email')
allow = request.POST.get('allow') # 用户协议，勾选后得到：on
print('手机 验证码', uphone, code, request.session.get('message_code'))
# todo:检验参数合法性
# 判断参数不能为空
if not all([username, password, password2, email, uphone, code]):
return render(request, 'register.html', {'errmsg': "注册信息不能为空"})
# 判断两次输入的密码是否一致
if password != password2:
return render(request, 'register.html', {'errmsg': "两次密码不一致"})
# 判断邮箱合法
if not re.match('^[a-z0-9][\w.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
return render(request, 'register.html', {'errmsg': "邮箱不合法"})
# 判断是否勾选用户协议
if allow != 'on':
return render(request, 'register.html', {'errmsg': "请勾选用户协议"})
# 判断手机输入是否正确
if not re.match('^1[345678]\d{9}$', uphone):
return render(request, 'register.html', {'errmsg': "手机输入不合法"})
# 判断验证码是否正确
if code != request.session.get('message_code'):
return render(request, 'register.html', {'errmsg': "验证码校验错误"})
# 处理业务：保存用户到数据表中
# django提供的方法，会对密码进行加密
user = User()
try:
user = User.objects.create_user(username,
email,
password,
uphone=uphone) # type: User
# 修改用户状态为未激活
user.is_active = False
user.save()
except IntegrityError:
# 判断用户是否存在
return render(request, 'register.html', {'errmsg': "用户名已存在"})
# todo:发送激活邮件
token = user.generate_active_token()
# 同步发送：会阻塞
# RegisterView.send_active_email(username, email, token)
# 使用celery异步发送：不会阻塞
# 会保存方法名
send_active_email.delay(username, email, token)
return HttpResponse("注册成功！")
def post(self, request):
# 1.接受数据
username = request.POST.get('user_name')
password = request.POST.get('pwd')
email = request.POST.get('email')
# 2.检验数据
# 数据缺失
if not all([username, password, email]):
return render(request, 'register.html', {'errmsg': '数据不完整'})
# 检验邮箱合法性
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
return render(request, 'register.html', {'errmsg': '请输入合法邮箱'})
# 检验密码是否一致
cpwd = request.POST.get('cpwd')
if password != cpwd:
return render(request, 'register.html', {'errmsg': '密码不一致'})
# 是否同意协议
is_allow = request.POST.get('allow')
if is_allow != 'on':
return render(request, 'register.html', {'errmsg': '请同意协议'})
# 检查用户名是否存在
try:
user = User.objects.get(username=username)
except:
# 用户名不存在
user = None
if user:
return render(request, 'register.html', {'errmsg': '用户名已存在'})
# 3.业务处理
user = User()
user.username = username
user.password = md5(password.encode('utf-8')).hexdigest() # 存储密码的MD5值
user.email = email
user.is_active = 0 # 默认未激活
user.save()
# 发送激活邮件，设置激活链接(标识用户唯一性)： /users/active/1/
# 加密用户身份信息
serializer = Serializer(settings.SECRET_KEY,
3600) # 使用django提供的token， 1小时过期
info = {'confirm': user.id}
token = serializer.dumps(info).decode()
# celery发送邮件
send_active_email.delay(email, username, token)
# 4.返回响应
return redirect(reverse('goods:index'))
def post(self, request):
name = request.POST.get('user_name')
pwd = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
if not all([name, pwd, email, allow]):
return redirect(reversed('users:register'))
if re.match(r'/^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$/',
email):
return render(request, 'register.html', {'errmsg': '邮箱格式错误'})
if allow != 'on':
return render(request, 'register.html', {'errmsg': '请勾选用户协议'})
try:
# 新创建的用户名存到数据库 create-user就是专门用数据库新创建的
user = User.objects.create_user(name, email, pwd)
except db.IntegrityError:
return render(request, 'register.html', {'errmsg': '用户名已经注册'})
user.is_active = False
user.save()
token = user.generate_active_token()
send_active_email.delay(email, name, token)
# send_mail()
# user 是通过models中的user类来创建的的对象，调用生成token的方法
# # def send_active_email(email, name, token):
# # """封装发送邮件方法"""
#
#
# from django.core.mail import send_mail
# subject = "淘淘乐用户激活" # 标题
# body = "" # 文本邮件体
# sender = settings.EMAIL_FROM # 发件人
# receiver = [email] # 接收人
# html_body = '<h1>尊敬的用户 %s, 感谢您注册淘淘乐！</h1>' \
# '<br/><p>请点击此链接激活您的帐号<a href="http://127.0.0.1:8000/users/active/%s">' \
# 'http://127.0.0.1:8000/users/active/%s</a></p>' % (name, token, token)
# send_mail(subject, body, sender, receiver, html_message=html_body)
# return HttpResponse('ceshi')
return redirect(reverse('goods:index'))
def post(self, request):
'''处理POST请求,返回do_register函数处理注册逻辑'''
'''注册逻辑'''
'''获取用户注册的参数'''
username = request.POST.get('username')
password = request.POST.get('password')
password2 = request.POST.get('password2')
email = request.POST.get('email')
allow = request.POST.get('allow')
'''校验参数的合法性'''
'''逻辑判断0 0.0 '' None [] () {} 都返回False'''
# all:所有的变量都为True，all函数才返回True，否则返回False
if not all([username, password, password2, email]):
return render(request, 'register.html', {'message': '参数不完整！！'})
# 判断两次密码是否一致
if password != password2:
return render(request, 'register.html', {'message': '密码输入不一致！！'})
# 判断是否勾选了用户协议
if allow != 'on':
return render(request, 'register.html', {'message': '请勾选用户协议！！'})
# 判断邮箱输入是否有误
if not re.match(r'^[a-z0-9][\w.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
return render(request, 'register.html', {'message': '邮箱格式错误！！'})
# 把用户输入的数据保存到数据库中，create_user：是django提供的方法，会对密码加密后保存到数据库
try:
user = User.objects.create_user(username, email, password)
except IntegrityError:
return render(request, 'register.html', {'message': '用户名已存在'})
# 邮箱验证
# 获取token
serizar = TimedJSONWebSignatureSerializer(settings.SECRET_KEY, 3600)
token = serizar.dumps({'confirm': user.id})
token = token.decode() # 转成字符串类型
# self.send_active_email(username,email,token)
# 利用celery异步发送邮件
send_active_email.delay(username, email, token)
# 邮件验证
user.is_active = False
user.save()
# todo 发送激活邮件
# 响应返回html页面,重定向到登陆界面,反向解析
return redirect(reverse("users:login"))
def post(self, request):
"""处理注册逻辑"""
# 1.获取请求参数，注册数据
user_name = request.POST.get('user_name')
pwd = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
# 2.校验请求参数
# 判断请求参数是否齐全：all(可迭代对象)，只要有一个为空，就返回空、假
if not all([user_name, pwd, email]):
# 具体如何处理用户参数不全，根据需求文档而定
return redirect(reverse('users:register'))
# 3.判断邮箱格式
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
return render(request, 'register.html', {'errmsg':'邮箱格式错误'})
# 4.判断是否勾选用户协议
if allow != 'on':
return render(request, 'register.html', {'errmsg': '请勾选用户协议'})
# 5.保存用户注册数据到数据库：Django的用户认证系统，自动加密密码，重名的异常，不需要调用save()
try:
user = User.objects.create_user(user_name, email, pwd)
except IntegrityError:
# 重名异常
return render(request, 'register.html', {'errmsg': '用户已存在'})
# 6.重置激活状态（注意）:默认为True
user.is_active = False
# 修改后自己保存
user.save()
# 7.生成token
token = user.generate_active_token()
# 8.Celery异步发送激活邮件
send_active_email.delay(email, user_name, token)
# 9.响应结果：实际开发根据需求文档，我在这里重定向到首页
return redirect(reverse('goods:index'))
# def register(request):
# """函数视图：注册"""
#
# if request.method == 'GET':
# # 提供注册页面
# return render(request, 'register.html')
#
# if request.method == 'POST':
# # 处理注册逻辑
# return HttpResponse('收到POST请求，需要处理注册逻辑')
def post(self, request):
# 接受用户注册参数
user_name = request.POST.get('user_name')
pwd = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
# 校验用户注册参数
# 只要有一个数据为空，就返回假，只有全部为真则为真
if not all([user_name, pwd, email]):
# 公司中，根据开发文档实现需求
return redirect(reverse('users:register'))
# 判断邮箱格式
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
return render(request, 'register.html', {'errmsg': '邮箱格式错误'})
# 是否勾选了同意
# on == 勾选
if allow != 'on':
return render(request, 'register.html', {'errmsg': '请勾选用户协议'})
# 保存用户注册参数
# 以下的代码不用调用save保存（只有使用，user.object.create()或者user.
try:
user = User.objects.create_user(user_name, email, pwd)
#重名异常判断
except db.IntegrityError:
return render(request, 'register.html', {'errmsg': '用户已存在'})
# 重置激活的状态
user.is_active = False
# 注意：重置之后需要重新保存一下，每次调用模型类改动时，都需要保存
# 还可以使用creat（），但是都需要调用save保存
user.save()
# 发送激活邮件
# 把激活状态变为TURE
# 生成token
token = user.generate_active_token()
# 异步发送邮件，生成token 响应之前 发送邮件，激活
# 在这里有个delay 就是用于触发异步任务的
send_active_email.delay(email, user_name, token)
return redirect(reverse('goods:index'))
# def register(request):
# #注册,提供注册页面与逻辑
# # 如果在一个视同中，实现多种请求逻辑，请求地址使用相同的地址，只是请求方法不同
# if request.method == 'GET':
# return render(request,'register.html')
# if request.method =='POST':
# return HttpResponse ('这里是请求逻辑')
def post(self, request):
# 1获取传过来的数据
username = request.POST.get('user_name') # 用户名
psw = request.POST.get('pwd') # 密码
email = request.POST.get('email') # 邮件
allow = request.POST.get('allow') # 同意协议
# 2校验数据
# 判断是否为空
if not all([username, psw, email]):
return redirect(reverse('users:register'))
# 判断邮箱格式
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
return render(request, 'register.html', {'errmsg': '邮箱格式错误'})
# checkbox如果勾选 后穿过来一个on
if allow != 'on':
return render(request, 'register.html', {'errmsg': '没有同意协议'})
# 3执行注册逻辑
# 保存到数据库 insert
# user = User()
# user.username = username
# user.password = psw
# user.save() #insert
# 密码加密 123456 + jfdsldsfjldsfjldsjk+当前时间 加盐值 混淆
try:
user = User.objects.create_user(username=username, email=email, password=psw)
except db.IntegrityError:
return render(request, 'register.html', {'errmsg': '用户已经注册'})
# django默认是激活的 不符合需求 改为不激活
user.is_active = False
# 保存到数据库 insert
user.save()
# 生成token 包含user.id 生成token的过程 叫签名
token = user.generate_active_token()
# 给用户发送激活邮件
# 接收邮件的人 可以有多个
# recipient_list = [user.email] 应该发给user.email
# 为了测试方便 就写固定了了
recipient_list = ['*****@*****.**'] # user.email
# 发送邮件的方法 发邮件是耗时的 处理图片 音视频 需要异步执行
# 通过delay调用 通知work执行任务
send_active_email.delay(recipient_list, user.username, token)
# 5给浏览器响应
return HttpResponse('注册成功，请去激活')
def post(self, request):
# 注册页面逻辑处理
username = request.POST.get('user_name')
password = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
# 参数验证
if not all([username, password, email]):
# 参数不完整
return render(request, 'register.html', {'errmsg': '数据不完整'})
if not re.match(r'^[a-z0-9][\w.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
# 邮箱格式不正确
return render(request, 'register.html', {'errmsg': '邮箱格式不正确'})
if allow != 'on':
# 协议不同意
return render(request, 'register.html', {'errmsg': '请首先同意协议'})
# 业务处理：用户注册，验证用户是否存在
try:
# 用户已经存在
user = User.objects.get(username=username)
except User.DoesNotExist:
# 用户名不存在可以注册
user = None
if user:
return render(request, 'register.html', {'errmsg': '用户已存在'})
try:
user = User.objects.create_user(username, email, password)
user.is_active = 0
user.save()
except Exception as e:
return render(request, 'register.html', {'errmsg': '用户注册失败，请重试'})
# 设置激活链接/user/active/user_id
serializer = Serializer(settings.SECRET_KEY, 3600)
info = {'confirm': user.id}
token = serializer.dumps(info).decode('utf8')
# 发送邮件,delay放到队列中
send_active_email.delay(email, username, token)
# 返回结果, namespace=goods下面的name=index的视图函数
return redirect(reverse('goods:index'))
def post(self, request):
"""处理post请求，处理注册数据"""
# 获取前端发送的数据/参数
user_name = request.POST.get("user_name")
password = request.POST.get("pwd")
email = request.POST.get("email")
allow = request.POST.get("allow")
# 参数校验
if not all([user_name, password, email]):
# 如果参数不完整，从定向到注册页面
return redirect(reverse("users:register"))
if not re.match(r"^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$",
email):
# 如果email格式不正确
return render(request, "register.html", {"errmsg": "邮箱格式不正确！"})
if allow != "on":
# 如果用户没有勾选协议
return render(request, "register.html", {"errmsg": "请同意协议！"})
# 进行业务逻辑处理
# 将密码加密
# 将用户数据保存到数据库中
# user = User()
# user.save()
# 使用django的认证系统创建用户
try:
user = User.objects.create_user(user_name, email, password)
except db.IntegrityError:
# 如果抛出此异常，表示用户已经注册
return render(request, "register.html", {"errmsg": "用户已注册！"})
# 将用户的激活状态设置为假
user.is_active = False
user.save()
# 生成激活token
token = user.generate_active_token()
# 使用celery发送邮件
send_active_email.delay(email, user_name, token)
# 返回给前端结果
return redirect(reverse("goods:index"))
def post(self, request):
"""处理注册表单逻辑"""
# 接受注册请求参数
user_name = request.POST.get('user_name')
pwd = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
# 校验注册请求参数
# 判断是否缺少参数:只要有一个为空,就返回假
if not all([user_name, pwd, email]):
# 公司中,以开发文档为准
return redirect(reverse('users:register'))
# 判断邮箱格式
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
return render(request, 'register.html', {'error': '邮箱格式错误'})
# 判断是否勾选了用户协议
if allow != 'on':
return render(request, 'register.html', {'error': '请勾选用户协议'})
# 保存注册请求参数
try:
user = User.objects.create_user(user_name, email, pwd)
except db.IntegrityError:
return render(request, 'register.html', {'error': '用户已存在'})
# 重置激活状态
user.is_active = False
user.save()
# 生成token
token = user.generate_active_token()
# 异步发送激活邮件:不能够阻塞 return
# send_active_email(email, user_name, token) # 错误写法
# delay : 触发异步任务
send_active_email.delay(email, user_name, token)
# 响应结果
return redirect(reverse('users:login'))
def post(self, request):
"""处理注册逻辑,存储注册信息"""
# 接受用户注册参数
user_name = request.POST.get('user_name')
pwd = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
# 校验用户注册参数: 只要有一个数据为空,那么久返回假,只有全部为真,才返回真
if not all([user_name, pwd, email]):
# 公司中,根据开发文档实现需求
return redirect(reverse('users:register'))
# 判断邮箱格式
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
return render(request, 'register.html', {'errmsg': '邮箱格式错误'})
# 判断是否勾选了协议
if allow != 'on':
return render(request, 'register.html', {'errmsg': '请勾选用户协议'})
# 保存用户注册参数
try:
user = User.objects.create_user(user_name, email, pwd)
except db.IntegrityError: # 重名异常判断
return render(request, 'register.html', {'errmsg': '用户已存在'})
# 重置激活状态 : 需要使用邮件激活
user.is_active = False
# 注意: 需要重新保存一下
user.save()
# 生成token
token = user.generate_active_token()
# 异步发送激活邮件:不能阻塞HttpResponse
# send_active_email(email, user_name, token) # 这是错误写法,不会触发异步的send_active_email
# 正确的写法 delay()触发异步任务
send_active_email.delay(email, user_name, token)
# return HttpResponse('这里是处理注册逻辑')
return redirect(reverse('goods:index'))
def post(self, request):
# 获取传入的数据
username = request.POST.get("user_name")
psw = request.POST.get("pwd")
allow = request.POST.get("allow")
email = request.POST.get("email")
# 检验数据
# 判断是否为空
if not all([username, psw, email]):
return redirect(reverse('users:register'))
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
return render(request, 'register.html', {'error': '邮箱格式错误 '})
if allow != 'on':
return render(request, 'register.html', {'err': '请勾选协议'})
# 密码加密
try:
user = User.objects.create_user(username=username,
email=email,
password=psw)
except db.IntegrityError:
return render(request, 'register.html', {'error': '用户已存在 '})
user.is_active = False
user.save()
# 给用户发邮件
# 生成token 包含user.id 生成token的过程 叫签名:
token = user.generate_active_token()
# 给用户发送激活邮件
# 接收邮件的人 可以有多个
# recipient_list = [user.email] 应该发给user.email
# 为了测试方便 就写固定了了
recipient_list = ['*****@*****.**'] # user.email
# 发送邮件的方法 发邮件是耗时的 处理图片 音视频 需要异步执行
# 通过delay调用 通知work执行任务
send_active_email.delay(recipient_list, user.username, token)
# 5给浏览器响应
# return render(request, 'index.html')
return redirect('/goods/index')
def post(self, request):
"""处理用户注册"""
uname = request.POST.get("user_name")
passwd = request.POST.get("pwd")
email = request.POST.get("email")
allow = request.POST.get("allow")
if not all([uname, passwd, email, allow]) or allow != "on" \
or not re.match(r"^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$", email):
return render(request, "register.html")
try:
user = User.objects.create_user(uname, email, passwd)
except db.IntegrityError:
return render(request, "register.html", {"errmsg": "用户名已注册"})
user.is_active = False
user.save()
# 生成激活令牌
token = user.generate_active_token()
send_active_email.delay(uname, email, token)
return redirect(reverse("goods:index"))
def post(self, request):
# 获取post参数
username = request.POST.get('username')
password = request.POST.get('password')
password2 = request.POST.get('password2')
email = request.POST.get('email')
allow = request.POST.get('allow')
# 判断参数不能为空
if not all([username, password, password2, email, allow]):
return render(request, 'register.html', {'ERRORMSG': '参数不能为空'})
# 判断输入两次密码一致
if password != password2:
return render(request, 'register.html', {'ERRORMSG': '输入两次密码不一致'})
# 判断邮箱合法性
if not re.match('^[a-z0-9][\w.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
return render(request, 'register.html', {'ERRORMSG': '输入邮箱不合法'})
# 判断是否勾选用户协议
if allow != 'on':
return render(request, 'register.html', {'ERRORMSG': '未勾选用户协议'})
try:
# 处理业务：保存用户到数据库表中
user = User.objects.create_user(username, email, password)
# 修改用户状态为未激活
user.is_active = False
user.save()
# 判断用户是否存在
except IntegrityError:
return render(request, 'register.html', {'ERRORMSG': '用户已存在'})
# todo:发送激活邮件
token = user.generate_active_token()
# 同步发送会阻塞
# RegisterView.send_active_email(username,email,token)
# 异步调用delay方法
send_active_email.delay(username, email, token)
return HttpResponse('注册成功，进入登陆界面')
def post(self, request):
"""对应post请求方式，接收处理用户的注册数据"""
# 接收传入的参数
user_name = request.POST.get("user_name")
password = request.POST.get("pwd")
email = request.POST.get("email")
allow = request.POST.get("allow")
# 检验参数的正确性
if not all([user_name, password, email]):
# 重定向到注册页面
return redirect(reverse("users:register"))
if not re.match(r"^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$",
email):
# 返回错误信息
return render(request, "register.html", {"errmsg": "邮箱格式不正确"})
if allow != "on":
return render(request, "register.html", {"errmsg": "请接收注册协议！"})
# 进行业务逻辑处理，将数据保存到数据库
# 注意用户的密码要加密，
try:
# django的AbstractUser基类提供的创建用户的方法
user = User.objects.create_user(user_name, email, password)
except db.IntegrityError:
# 如果用户名已存在，则抛出此异常信息
return render(request, "register.html", {"errmsg": "用户名已存在！"})
# 将用户的激活状态设置为假
user.is_active = False
user.save()
# 为用户生成激活口令
token = user.generate_active_token()
# 使用celery异步发送邮件
send_active_email.delay(user_name, email, token)
# 将结果返回给前端
return redirect(reverse("goods:index"))
def post(self, request):
# 接收数据
username = request.POST.get('user_name')
password = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
# 数据校验
if not all([username, password, email]):
return render(request, 'register.html', {'errmsg': '数据不完整'})
if not re.match(r'^[a-z0-9][\w.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
return render(request, 'register.html', {'errmsg': '邮箱格式不正确'})
if allow != 'on':
return render(request, 'register.html', {'errmsg': '请仔细阅读协议并同意'})
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = None
else:
# 此处简写，应该判断user是否为None更严谨
return render(request, 'register.html', {'errmsg': '用户已存在'})
# 业务处理
user = User.objects.create_user(username, email, password)
user.is_active = 0
user.save()
# 生成邮件token
serializer = Serializer(settings.SECRET_KEY, 3600)
info = {'confirm': user.id}
token = serializer.dumps(info)
token = token.decode()
# 发送邮件
send_active_email.delay(email, username, token)
# 返回应答
return redirect(reverse('goods:index'))
def post(self, request):
"""用于处理post逻辑"""
# 1.接收用户注册信息、参数
user_name = request.POST.get('user_name')
password = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
# 2.参数校验
# 2.1 判断参数是否都传入:all(),只有校验的对象都为真，返回True
if not all([user_name, password, email]):
# 重新刷新注册页面：具体如何实现，根据公司需求而定
return redirect(reverse('users:register'))
# 2.2 校验邮箱地址格式
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
return render(request, 'register.html', {'errmsg':'邮箱地址格式错误'})
# 2.3 判断是否勾选用户协议
if allow != 'on':
return render(request, 'register.html', {'errmsg':'请勾选用户协议'})
# 3.保存注册数据:使用django自带的用户认证系统，默认对密码加密在保存，自动保存的
try:
# 3.1 判断用户是否存在
user = User.objects.create_user(user_name, email, password)
except IntegrityError:
return render(request, 'register.html', {'errmsg':'用户已存在'})
# 4.重置激活状态：因为django认证系统默认把用户的激活状态置为True
user.is_active = False
user.save()
# 5.生成激活的token
token = user.generate_active_token()
# 6.异步发送激活邮件
send_active_email.delay(email, user_name, token)
# 7.响应结果给用户：根据产品需求而定
return redirect(reverse('goods:index'))
def post(self, request):
"""处理注册逻辑"""
# 1. 接收用户注册请求数据
user_name = request.POST.get('user_name')
pwd = request.POST.get('pwd')
cpwd = request.POST.get('cpwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
# 2. 校验数据是否为空
if not all([user_name, pwd, cpwd, email]):
return redirect(reverse('users:register'))
# 3. 校验数据是否有效
if not re.match(r"^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$",
email):
return render(request, 'register.html', {'errmsg': '您输入的邮箱格式不正确'})
# 4. 校验是否已勾选用户协议
if allow != 'on':
return render(request, 'register.html', {'errmsg': '请勾选用户协议'})
# 5. 保存数据
try:
user = User.objects.create_user(user_name, email, pwd)
except db.IntegrityError:
return render(request, 'register.html', {'errmsg': '该用户名已注册'})
# 6. 将用户初始化为未激活状态
user.is_active = False
user.save()
# 生产token
token = user.generate_active_token()
# 7. 发送激活邮件
send_active_email.delay(email, user_name, token)
return redirect(reverse('goods:index'))
# def register(request):
# """函数视图"""
#
# if request.method == 'GET':
# """提供注册页面"""
# return render(request, 'register.html')
# if request.method == 'POST':
# """处理注册逻辑，保存注册信息"""
# return HttpResponse("注册逻辑处理")
def post(self, request):
username = request.POST.get('user_name')
password = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
# return render(request, 'register.html', {'errmsg': '数据不完整'})
#print(username, password, email, allow)
if not all([username, password, email]):
#print('<' * 10)
return render(request, 'register.html', {'errmsg': '数据不完整'})
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
return render(request, 'register.html', {'errmsg': '邮箱地址不对'})
if allow != 'on':
# print('<' * 10)
return render(request, 'register.html', {'errmsg': '请同意协议'})
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = None
if user:
return render(request, 'register.html', {'errmsg': '用户已存在'})
user = User.objects.create_user(username, email, password)
user.is_active = 0
user.save()
serializer = Serializer(settings.SECRET_KEY, 3600)
info = {'confirm': user.id}
token = serializer.dumps(info) #dumps 注意s
token = token.decode('utf8')
send_active_email.delay(email, username, token)
return redirect(reverse('goods:index'))
def post(self, request):
"""对应post请求方式，接收处理用户的注册数据"""
# 接收传入的参数
user_name = request.POST.get("user_name")
password = request.POST.get("pwd")
email = request.POST.get("email")
allow = request.POST.get("allow")
# 检验参数的正确性
if not all([user_name, password, email]):
# 重定向到注册页面
return redirect(reverse("users:register"))
if not re.match(r"^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$", email):
# 返回错误信息
return render(request, "register.html", {"errmsg": "邮箱格式不正确"})
if allow != "on":
return render(request, "register.html", {"errmsg": "请接收注册协议！"})
# 进行业务逻辑处理，将数据保存到数据库
# 注意用户的密码要加密，
try:
# django的AbstractUser基类提供的创建用户的方法
user = User.objects.create_user(user_name, email, password)
except db.IntegrityError:
# 如果用户名已存在，则抛出此异常信息
return render(request, "register.html", {"errmsg": "用户名已存在！"})
# 将用户的激活状态设置为假
user.is_active = False
user.save()
# 为用户生成激活口令
token = user.generate_active_token()
# 使用celery异步发送邮件
send_active_email.delay(user_name, email, token)
# 将结果返回给前端
return redirect(reverse("goods:index"))
def post(self, request):
user_name = request.POST.get('user_name')
password = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
if not all([user_name, password, email, allow]):
return redirect(reversed('users:register'))
if not re.match(r"^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$",
email):
return render(request, 'register.html', {'errmsg': '邮箱格式不正确'})
if allow != 'on':
return render(request, 'register.html', {'errmsg': '没有勾选用户协议'})
try:
user = User.objects.create_user(user_name, email, password)
except:
return render(request, 'register.html', {'errmsg': '用户已认证'})
user.is_active = False
user.save()
token = user.generate_active_token()
send_active_email.delay(email, user_name, token)
return redirect(reverse('users:login'))
def register_handles(request):
'''进行用户注册数据处理'''
# 接收数据
username = request.POST.get('user_name')
password = request.POST.get('pwd')
# cpassword = request.POST.get('cpwd')
email = request.POST.get('email')
# # 判断是否为空
# if not all([username, password, cpassword, email]):
# return render(request, 'df_user/register.html', {'errodata': '参数不能为空'})
# # 判断邮箱是否合理
# if not re.match(r'/^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$/')
# 数据库保存注册用户（方法1：用save保存）
# p = Passport()
# p.username = username
# p.password = password
# p.email = email
# p.save()
# 数据库保存注册用户（方法2：）
# passport = Passport(username=username, password=password, email=email)
# passport.save()
# Passport.objects.create(username=username, password=password, email=email)
# 数据库保存注册用户（方法3：函数封装）
passport = Passport.objects.add_one_passport(username=username,
password=password,
email=email)
# 生成激活的token
serializer = Serializer(settings.SECRET_KEY, 3600) # 设置链接失效时间为3600秒
token = serializer.dumps({'confirm': passport.id}) # dumps将id加密，返回的是byte类型
token = token.decode()
# 给用户的邮箱发送激活邮件
# send_mail('天天生鲜用户激活', '', settings.EMAIL_FROM, [email], html_message='<a href="www.baidu.com">百度</a>')
# send_mail('天天生鲜用户激活', '激活请点击', settings.EMAIL_FROM, [email], )
send_active_email.delay(token, username,
email) # delay延时，是设置异步执行，邮箱发送和页面跳转同时进行
return redirect('/user/login/')
def post(self, request):
username = request.POST.get('username')
password = request.POST.get('password')
password2 = request.POST.get('password2')
email = request.POST.get('email')
allow = request.POST.get('allow')
# 'message'用来返回提示信息到注册界面
if not all([username, password, password2, email, allow]):
return render(request, 'register.html', {'message': '请填写完整'})
if password != password2:
return render(request, 'register.html', {'message': '两次输入的密码不一致'})
if allow != 'on':
return render(request, 'register.html', {'message': '请先同意用户协议'})
if not re.match('^[a-z0-9][\w.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
return render(request, 'register.html', {'message': '邮箱格式不正确'})
# 业务处理
# 保存用户到数据库中
# create_user: 是django提供的方法, 会对密码进行加密后再保存到数据库
try:
user = User.objects.create_user(username=username,
password=password,
email=email)
# 将用户激活状态设置为未激活
User.objects.filter(id=user.id).update(is_active=False)
except IntegrityError:
return render(request, 'register.html', {'message': '用户名已存在'})
# 发送激活邮件
token = user.generate_active_token()
send_active_email.delay(username, email, token)
return redirect(reverse("users:login"))
def post(self, request):
'''处理用户注册数据'''
username = request.POST.get('user_name')
password = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
if not all([username, password, email]):
return render(request, 'register.html', {'error_msg': '数据不完整'})
if not re.match(r"^[a-z0-9][\w.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$",
email):
return render(request, 'register.html', {"error_msg": "邮箱格式不正确"})
if allow != "on":
return render(request, "register.html", {"error_msg": "请勾选同意"})
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = None
if user:
return render(request, "register.html", {"error_msg": "用户名已存在"})
user = User.objects.create_user(username, email, password)
user.is_active = 0
user.save()
serializer = Serializer(settings.SECRET_KEY, 3600) # 有效期1小时
info = {"confirm": user.id}
token = serializer.dumps(info)
token_ = token.decode('utf-8')
send_active_email.delay(email, username, token_)
# subject = "海马生鲜欢迎你" # 邮件标题
# message = "how are you" # 邮件正文
# sender = settings.EMAIL_FROM # 发件人
# receiver = [email] # 收件人
# html_message='''
# <h1>%s 恭喜您成为海马生鲜注册会员</h1><br/><h3>请您在1小时内点击以下链接进行账户激
# 活</h3><a
# href="http://127.0.0.1:8000/active/%s">http://127.0.0.1:8000/active/%s</a>
# ''' % (username, token_, token_)
# send_mail(subject, message, sender, receiver,html_message=html_message)
return redirect(reverse("index"))
def post(self, request):
#获取注册请求参数
user_name = request.POST.get('user_name')
password = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
##校验注册请求参数 --- 注册逻辑不涉及查重
# 判断是否缺少参数:只要有一个为空,就返回假---返回注册页面
if not all([user_name, password, email]):
return redirect(reverse('users:register'))
# 判断邮箱格式是否正确 --- 取反
if not re.match(r"^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$",
email):
return render(request, 'register.html', {'errormsg': '邮箱格式不正确'})
#判断是否勾选用户协议
if allow != 'on':
return render(request, 'register.html', {'errormsg': '没有勾选用户协议'})
#保存注册请求参数 到数据库 --- 属于隐私信息需要加密--可以使用django的用户认证系统
try:
user = User.objects.create_user(user_name, email, password)
except db.IntegrityError:
return render(request, 'register.html', {'errormsg': '用户名已存在'})
# 保存的用户默认是激活状态，需要手动设置成未激活状态
user.is_active = False
#保存这个用户的信息到数据库
user.save()
# 生成token --- 调用模型类中定义的生成token的方法。
token = user.generate_active_token()
# send_active_email(email, user_name, token) # 错误写法
# delay : 触发异步任务 --- 不然celery不认识
send_active_email.delay(email, user_name, token)
return redirect(reverse('goods:index'))
def post(self, request):
"""注册信息处理"""
# 1. 接受数据
username = request.POST.get('user_name')
password = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
# 2. 对数据进行校验
# 是否接收到数据
# all 方法,判断参数是否为可迭代对象,
if not all([username, password, email]):
return render(request, 'register.html', {'errorMsg': '数据不完整'})
# 校验邮箱
if not re.match(r"^[a-z0-9][\w.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$",
email):
return render(request, 'register.html', {'errorMsg': '邮箱格式错误'})
# 校验是否同意协议
if allow != 'on':
return render(request, 'reigister.html', {'errorMsg': '请同意协议'})
# 3. 进行业务处理,如用户注册
# 将注册用户信息放置在数据库中
# user = User() # 创建一个 user 对象,通过操作对象的属性或方法,来对数据库进行操作,ORM操作
# user.username = username
# user.password = password
# user.email = email
# 更新数据库
# user.save()
# 校验用户名是否重复
try:
user = User.objects.get(username=username)
except User.DoesNotExist as e:
# 用户名不存在
user = None
if user:
return render(request, 'register.html', {'errorMsg': '用户名已存在'})
# 使用 django 自带的认证系统
user = User.objects.create_user(username, email, password)
# 新用户应该是未激活的状态
user.is_active = 0 # 设置新用户账号未激活
user.save()
# 4. 向用户发送激活邮件
# 5. 使用 itsdangerous 将用户信息加密,防止用户信息泄露
serializer = Serializer(settings.SECRET_KEY,
3600) # 选择 django 自带的秘钥生成一个对象,生效时间为 3600s
info = {'confirm': user.id}
token = serializer.dumps(info) # 加密时,加密对象是字典,解密时生成的对象也是字典
token = token.decode() # 解密出来的默认为字节形式,解码为 uft-8 格式
# 发邮件
send_active_email.delay(email, username,
token) # delay 是任务函数经过装饰后,所拥有的方法
# 4. 返回应答
return redirect(reverse('goods:index')) # reverse 反向解析
def post(self, request):
"""处理注册逻辑，存储注册信息"""
# 接收用户注册的参数
user_name = request.POST.get('user_name')
pwd = request.POST.get('pwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
# 校验用户注册的参数: all()只要有一个数据为空，那么就返回假，只有全部为真，才返回真
if not all([user_name, pwd, email]):
# 公司中，根据开发文档实现需求
return redirect(reverse('users:register'))
# 判断邮箱格式
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
return render(request, 'register.html', {'errmsg': '邮箱格式错误'})
# 判断是否勾选了协议
if allow != 'on':
return render(request, 'register.html', {'errmsg': '请勾选用户协议'})
# 保存用户注册的参数
try:
user = User.objects.create_user(user_name, email, pwd)
except db.IntegrityError:
return render(request, 'register.html', {'errmsg': '用户已存在'})
# 重置激活状态：需要使用邮件激活
user.is_active = False
# 注意：需要重新保存以下
user.save()
# 生成token
token = user.generate_active_token()
# 发送激活邮件，不能够阻塞HttpResponse -->异步发送
# send_active_email(email, user_name, token) # 错误写法，不会粗放异步的send_active_email
# 正确的写法
send_active_email.delay(email, user_name, token)
# from django.core.mail import send_mail
#
# subject = "天天生鲜用户激活" # 标题
# body = "" # 文本邮件框
# sender = settings.EMAIL_FORM # 发件人
# receive = [email] # 收件人
# html_body = '<h1>尊敬的用户 %s ,感谢您注册天天生鲜！</h1>'\
# '<br/><p>请点击此链接激活您的账号<a href="http://127.0.0.1:8000/users/active/%s">'\
# 'http://127.0.0.1:8000/users/active/%s</a></p>' % (user_name, token, token)
# send_mail(subject, body, sender, receive, html_message=html_body)
return redirect(reverse('goods:index'))
# 函数视图
# def register(request):
# """注册"""
# if request.method == 'GET':
# """提供注册页面"""
# return render(request, 'register.html')
#
# if request.method == 'POST':
# """处理注册逻辑，存储注册信息"""
# return HttpResponse('这里是处理注册的逻辑')
def post(self, request):
"""用户注册校验"""
register_form = RegisterForm(request.POST)
if register_form.is_valid():
# 获取前端数据
username = register_form.cleaned_data['user_name']
pwd = register_form.cleaned_data['pwd']
cpwd = register_form.cleaned_data['cpwd']
email = register_form.cleaned_data['email']
allow = request.POST.get('allow')
# 校验参数是否完整
if not all([username, pwd, cpwd, email]):
return render(request,
'register.html',
context={
'errmsg': '请填写全部',
'register_form': register_form
})
# 校验用户是否存在
try:
use = User.objects.get(username=username)
except Exception as e:
use = None
if use:
return render(request,
'register.html',
context={
'errmsg': '用户名已存在',
'register_form': register_form
})
# 校验密码是否正确
if pwd != cpwd:
return render(request,
'register.html',
context={
'errmsg': '两次密码不一致',
'register_form': register_form
})
# 校验协议是否勾选
if allow != 'on':
return render(request,
'register.html',
context={
'errmsg': '请勾选协议',
'register_form': register_form
})
# 检查邮箱不能重复
try:
user = User.objects.get(email=email)
except Exception as e:
user = None
if user:
return render(request,
'register.html',
context={
'errmsg': '邮箱已经被注册',
'register_form': register_form
})
# 创建用户
user = User.objects.create_user(username=username,
password=pwd,
email=email)
# 上边的方法会自动将 is_active 改为1 也就是邮箱激活状态， 所以下边需要修改一下
user.is_active = 0
user.save()
# 加密用户信息生成激活token
serializer = Serializer(SECRET_KEY, 3600)
info = {'confirm': user.id}
token = serializer.dumps(info)
# 获取到的数据是bytes类型的，需要解码
token = token.decode()
# 发送邮件
send_active_email.delay(email, token, user.username)
return redirect(reverse('user:login'))
else:
return render(request,
'register.html',
context={'register_form': register_form})
