def get(self, request):
code = request.GET.get('code')
if not code:
return http.HttpResponseForbidden("缺少code")
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
try:
aaaaaccess_token = oauth.get_access_token(code)
openid = oauth.get_open_id(aaaaaccess_token)
except Exception as e:
logger.error(e)
return http.HttpResponseServerError('OAuth2.0认证失败')
try:
oauth_user = OauthQQUser.objects.get(openid=openid)
except OauthQQUser.DoesNotExist:
# 没有帮顶qq
access_token = generate_access_token(openid)
context = {'access_token': access_token}
return render(request, 'oauth_callback.html', context)
else:
qq_user = oauth_user.user
login(request, qq_user)
response = redirect(reverse('contents:index'))
response.set_cookie('username',
qq_user.username,
max_age=3600 * 24 * 14)
return response
def get(self, request):
"""Oauth2.0认证"""
#接收Authorization Code
code = request.GET.get('code')
if not code:
return http.HttpResponseForbidden('缺少code')
#创建工具对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
try:
#携带code 向QQ服务器请求access_token
access_token = oauth.get_access_token(code)
#携带access_token 向QQ服务器请求openid
openid = oauth.get_open_id(access_token)
except Exception as e:
#如果上面获取的openid出错，验证失败
logger.error(e)
#返回结果
return http.HttpResponseServerError('OAuth2.0认证失败')
#判断openid是否绑定用户
try:
oauth_user = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
#如果openid没有绑定用户
#调用封装好的方法
access_token = generate_access_token(openid)
# #拿到access_token 字符串，拼接字典
context = {'access_token': access_token}
# #返回响应，重新渲染
return render(request, 'oauth_callback.html', context)
pass
else:
#如果已绑定用户
qq_user = oauth_user.user
#实现状态保持
login(request, qq_user)
#创建重定向到主页的对象
response = redirect(reverse('contents:index'))
#将用户信息写到cookie中，有效期15天
response.set_cookie('username',
qq_user.username,
max_age=3600 * 24 * 15)
#返回响应
return response
def get(self, request):
# 获取code
code = request.query_params.get("code")
if code is None:
return Response(status=status.HTTP_400_BAD_REQUEST)
# 通过code获取token值
oauth = OAuthWeibo(client_id=settings.WEIBO_CLIENT_ID,
client_secret=settings.WEIBO_CLIENT_SECRET,
redirect_uri=settings.WEIBO_REDIRECT_URI,
state=next)
try:
access_token = oauth.get_access_token(code)
except Exception as e:
return Response(status=status.HTTP_400_BAD_REQUEST)
try:
weibo_user = OAuthSinaUser.objects.get(access_token=access_token)
except OAuthSinaUser.DoesNotExist:
access_token_itsdangerous = generate_access_token(access_token)
return Response({'access_token': access_token_itsdangerous})
else:
token = jwt_login(weibo_user)
return Response({
'token': token,
'username': weibo_user.user.username,
'user_id': weibo_user.user.id})
def get(self, request):
'''
接收code值, 验证是否有openid, 返回结果
:param request:
:return:
'''
# 1.接收参数
code = request.GET.get('code')
# 2.检验
if not code:
return http.HttpResponseForbidden('缺少必传code')
# 3.生成QQLoginTool对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
# 4.调用对象的两个方法 ----> 获取 openid
try:
access_token = oauth.get_access_token(code)
openid = oauth.get_open_id(access_token)
except Exception as e:
logger.error(e)
return http.HttpResponseServerError('oauth2.0认证失败')
# 5.判断openid是否保存到了我们的数据库中
try:
oauth_user = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
# 7.如果没有, 做另一些事
# 7.1 把openid加密生成access_token
access_token = generate_access_token(openid)
# 7.2 返回access_token
context = {'access_token': access_token}
return render(request, 'oauth_callback.html', context=context)
else:
# 6.如果有, 登录成功, 返回首页
# 6.1 状态保持:
login(request, oauth_user.user)
response = redirect(reverse('contents:index'))
# 6.2 cookie
response.set_cookie('username',
oauth_user.user.username,
max_age=3600 * 24 * 15)
response = merge_cart_cookie_to_redis(request, response,
oauth_user.user)
return response
def get(self, request):
"""
实现QQ登陆的第二个接口,用于接收前端发来的code值,拿着code值去QQ服务器换取access_token,
拿着access_token换取openid,再拿着openid去数据库中查看用户是否是第一次进行QQ登陆
如用户不是第一次,则直接登陆成功
如用户是第一次,则把openid加密生成access_token并返回给前端
:param request: 请求对象
:return: 登陆成功或access_token
"""
# 1.接收code参数
code = request.GET.get('code')
# 2.校验参数,判断code是否存在
if not code:
return http.HttpResponseForbidden('缺少code参数')
# 3.创建工具对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
try:
# 4.携带code向QQ服务器请求access_token
access_token = oauth.get_access_token(code)
# 5.携带access_token向eQQ服务器请求openid
openid = oauth.get_open_id(access_token)
except Exception as e:
logger.error(e)
return http.HttpResponseServerError('oauth2.0认证失败')
# 6.判断用户账号是否使用QQ登陆过(openid是否在数据库中)
try:
oauth_user = OAuthQQUser.objects.get(openid=openid)
# 6.1 用户账号没使用QQ登陆过(openid不在数据库中)
except OAuthQQUser.DoesNotExist:
# 把openid加密成access_token
access_token = generate_access_token(openid)
context = {'access_token': access_token}
# 返回access_token并跳转到绑定页面
return render(request, 'oauth_callback.html', context)
# 6.2 用户账号使用QQ登陆过(openid在数据库中)
else:
# 根据user外键,获取对应的QQ用户
qq_user = oauth_user.user
# 实现状态保持
login(request, qq_user)
# # 创建重定向到首页的对象
# response = redirect(reverse('contents:index'))
# 重定向到首页或用户要前往的页面
next = request.GET.get('state')
if next:
response = redirect(next)
else:
response = redirect(reverse('contents:index'))
# 将用户名写入cookie,有效期15天
response.set_cookie('username',
qq_user.username,
max_age=3600 * 24 * 15)
# 合并购物车数据
response = merge_cart_cookie_to_redis(request, response)
# 返回响应
return response
def get(self, request):
'''oauth2.0认证'''
# 1.接收code参数(查询字符串)
code = request.GET.get('code')
# 2.判断该参数是否存在
if not code:
return JsonResponse({'code': 400, 'errmsg': "缺少code参数"})
# 3.生成QQLoginTool工具类对象
oauth = OAuthQQ(
client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI,
)
try:
# 4.调用对象的方法, 发送请求, 获取access_token
access_token = oauth.get_access_token(code)
# 5.把token作为参数,再次发送请求, 获取openid
openid = oauth.get_open_id(access_token)
except Exception as e:
return JsonResponse({'code': 400, 'errmsg': "给qq发送请求失败"})
# 6.把openid作为条件在OAuthQQUser中检索. 获取对象
try:
oauth_qq = OAuthQQUser.objects.get(openid=openid)
except Exception as e:
# 11.把openid加密为access_token
access_token = generate_access_token(openid)
# 12.把access_token返回
return JsonResponse({
'code': 300,
'errmsg': "ok",
'access_token': access_token
})
else:
# 7.如果能拿到OAuthQQUser的对象(说明对象存在)
user = oauth_qq.user
# 8.状态保持
login(request, user)
response = JsonResponse({'code': 0, 'errmsg': 'ok'})
# 9.设置cookie中的username
response.set_cookie('username',
user.username,
max_age=3600 * 24 * 14)
# 补充内容:购物车的合并
response = merge_cart_cookie_to_redis(request, response)
# 10.返回响应
return response
def get(self, request):
"""Oauth2.0认证"""
#接收Authorization Code
code = request.GET.get('code')
if not code:
return HttpResponseForbidden('缺少code')
# 创建工具对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URL)
try:
# 携带code向QQ服务器请求access_token
access_token = oauth.get_access_token(code)
# 携带access_token向QQ服务器请求openid
openid = oauth.get_open_id(access_token)
except Exception as e:
# 如果上面获取openid出错,则验证失败
logger.error(e)
#返回结果
return HttpResponseServerError('OAuth2.0认证失败')
try:
#查看是否有openid对应的用户
oauth_user = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
# 如果openid没绑定美多商城用户
# 调用我们封装好的方法,对openid进行加密,生成access_token字符串
access_token = generate_access_token(openid)
# 拿到access_token字符串后,拼接字典
context = {'access_token': access_token}
# 返回响应,重新渲染
return render(request, 'oauth_callback.html', context)
else:
# 如果openid已绑定美多商城用户
# 根据user外键,获取对应的QQ用户
qq_user = oauth_user.user
# 实现状态保持
login(request, qq_user)
# 创建重定向到主页的对象
response = redirect(reverse('contents:index'))
# 将用户信息写入到cookie中,有效期15天
response.set_cookie('username', qq_user, max_age=3600 * 24 * 15)
# 合并购物车
response = merge_cart_cookie_to_redis(request=request,
response=response)
# 返回响应
return response
def get(self, request):
"""Oauth2.0认证"""
# 获取前端发送过来的 code 参数:
code = request.GET.get('code')
if not code:
# 判断 code 参数是否存在
return http.JsonResponse({'code': 400, 'errmsg': '缺少code参数'})
# 调用我们安装的 QQLoginTool 工具类
# 创建工具对象
oauth = OAuthQQ(
client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI,
# 用户完成整个qq登陆流程之后，返回到美多到哪个页面
state=next # http://www.meiduo.site:8080/
)
try:
# 携带 code 向 QQ服务器 请求 access_token
access_token = oauth.get_access_token(code)
# 携带 access_token 向 QQ服务器 请求 openid
openid = oauth.get_open_id(access_token)
except Exception as e:
# 如果上面获取 openid 出错, 则验证失败
logger.error(e)
# 返回结果
return http.JsonResponse({
'code':
400,
'errmsg':
'用户code无效，oauth2.0认证失败, 即获取qq信息失败',
})
# 获取openid仅仅代表这用户QQ的身份是没有问题的
try:
# 去获取一哈这一个QQ对否已经已经绑定了用户
qq_uer = OAuthQQUser.objects.get(openid=openid)
except Exception as e:
# 用户没有绑定，返回加密后openid--
# 前端让用户数据用户名和密码，后续接口再去判断绑定
token = generate_access_token(openid) # 加密一哈
return http.JsonResponse({
'code': 400,
'errmsg': '未绑定',
'access_token': token
})
else:
# 如果用户已经绑定了QQ，就说明用户已经注册了美多美多用户
login(request, qq_uer.user)
response = http.JsonResponse({'code': 0, 'errmsg': 'ok'})
response.set_cookie('username', qq_uer.user.username)
return response
def get(self, request):
"""oauth2.0认证"""
# 接收Authorization Code
code = request.GET.get('code')
if not code:
return http.HttpResponseForbidden('缺少code')
# 创建工具对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
try:
# 携带 code 向 QQ服务器 请求 access_token(code)
access_token = oauth.get_access_token(code)
# 携带 access_token 向 QQ服务器 请求 openid
openid = oauth.get_open_id(access_token)
except Exception as e:
# 如果上面获取 openid 出错，则验证失败
logger.error(e)
# 返回结果
return http.HttpResponseServerError('OAuth2.0认证失败')
# 判断 openid 是否绑定过用户
try:
oauth_user = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
# 如果 openid 没绑定美多商城用户， 进入这里
# 调用我们封装号的方法， 对openid 进行加密， 生成 access_token 字符串
access_token = generate_access_token(openid)
# 返回响应， 重新渲染
context = {
'access_token': access_token
}
return render(request, 'oauth_callback.html', context)
else:
# 如果 openid 已绑定美多商城用户
# 根据 user 外键， 获取对应的 QQ用户
qq_user = oauth_user.user
# 实现状态保持
login(request, qq_user)
# 创建重定向到主页的对象
response = redirect(reverse("contents:index"))
# 将用户信息写入到 cookie 中， 有效期15天
response.set_cookie('username', qq_user.username, max_age=3600 * 24 * 15)
# 合并购物车
response = merge_cart_cookie_to_redis(request, qq_user, response)
# 返回响应
return response
def get(self, request):
# 获取前端发送过来的 code 参数:
code = request.GET.get('code')
if not code:
# 判断 code 参数是否存在
return http.JsonResponse({'code': 400,
'errmsg': '缺少code参数'})
# 调用安装的 QQLoginTool 工具类
# 创建工具对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
try:
# 携带 code 向 QQ服务器 请求 access_token
access_token = oauth.get_access_token(code)
# 携带 access_token 向 QQ服务器 请求 openid
openid = oauth.get_open_id(access_token)
except Exception as e:
# 如果上面获取 openid 出错, 则验证失败
logger.error(e)
# 返回结果
return http.JsonResponse({'code': 400,
'errmsg': '获取qq信息失败'})
try:
oauth_qq = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
# 把 openid 变为 access_token
access_token = generate_access_token(openid)
# 把 access_token 返回给前端
return http.JsonResponse({'code': 300,
'errmsg': 'ok',
'access_token': access_token})
else:
# 根据 user 外键, 获取对应的 QQ 用户(user)
user = oauth_qq.user
# 实现状态保持
login(request, user)
# 创建重定向到主页的对象
response = http.JsonResponse({'code': 0,
'errmsg': 'ok'})
# 将用户信息写入到 cookie 中，有效期14天
response.set_cookie('username',
user.username,
max_age=3600 * 24 * 14)
def get(self, request):
"""
:param request:
:return:
"""
code = request.GET.get('code')
if not code:
return http.HttpResponseForbidden('缺少必传参数')
# 3.获取QQLoginTool框架对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
try:
# 4.调用对象的方法, 发送请求给qq, 获取access_token
access_token = oauth.get_access_token(code)
# 5.根据 access_token 再次发送请求, 获取 openid
openid = oauth.get_open_id(access_token)
except Exception as e:
logger.error(e)
return http.HttpResponseServerError('oath2.0请求出错')
# 6.去保存openid的表中,获取一下, 查看有没有
try:
oauth_qq = OAuthQQUser.objects.get(openid=openid)
except Exception as e:
# 8.如果没有: 把openid加密形成: access_token 返回给前端
access_token = generate_access_token(openid)
context = {'access_token': access_token}
return render(request, 'oauth_callback.html', context=context)
else:
user = oauth_qq.user
# 7.如果有: 直接重定向到首页
# 7.1 保持状态
login(request, user)
response = redirect(reverse('contents:index'))
# 7.2 写入cookie值: username
response.set_cookie('username',
user.username,
max_age=3600 * 24 * 14)
# 7.3 重定向到首页
return response
def get(self, request):
"""Oauth2.0认证"""
# 接收Authorization Code
code = request.GET.get('code')
if not code:
return http.HttpResponseForbidden('缺少code')
# 创建工具对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
# 给第三方软件发送请求，需要ｔｒｙ一下。
try:
# 携带 code 向 QQ服务器 请求 access_token
access_token = oauth.get_access_token(code)
# 携带 access_token 向 QQ服务器 请求 openid
openid = oauth.get_open_id(access_token)
except Exception as e:
# 如果上面获取 openid 出错, 则验证失败
print(e)
# 返回结果
return http.HttpResponseServerError('OAuth2.0认证失败')
# 判断 openid 是否绑定过用户(判断用户是不是第一次ｑｑ登陆）
try:
oauth_user = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
# 如果openid没绑定美多商城用户
# 调用我们封装好的方法，对openid进行加密，生成access_token字符串
access_token = generate_access_token(openid)
# 拿到access_code字符串后，拼接字典
context = {'access_token': access_token}
# 返回响应，重新渲染
return render(request, 'oauth_callback.html', context)
else:
# 如果openid绑定美多商城用户
# 根据 user 外键, 获取对应的 QQ用户
qq_user = oauth_user.user
# 实现状态保持
login(request,qq_user)
# 创建重定向到主页的对象
response = redirect(reverse('contents:index'))
# 将用户信息写入到ｃｏｏｋｉｅ中，有效期１５天
response.set_cookie('username',qq_user.username,max_age=3600)
# 返回响应
return response
def get(self ,request ):
#提取參數
code = request.GET.get('code')
error = request.GET.get('error')
state = request.GET.get('state')
#判斷用戶是否授權
if error:
return redirect(reverse('users:login'))
try:
#請求line接口獲取id_token
id_token = get_id_token(code)
#判斷是否成功授權，若授權失敗，立即中止註冊
if not id_token:
return redirect(reverse('contents:index'))
#請求line接口驗證並解碼id_token
picture ,userid ,user_messages_dict = get_profile_information(id_token ,state )
except Exception as e:
logger.error(e)
return HttpResponseServerError('OAuth2.0認證失敗')
#判斷用戶是否存在
try:
oauth_line_user = OAuthLineUser.objects.get(userid=userid)
except Exception:
#用戶未用line登入過
#簽名用戶數據
access_token = generate_access_token(user_messages_dict)
#構造響應數據
contents = {
'access_token':access_token ,
'picture':picture ,
}
#返回用戶加密數據和line用戶註冊頁面
return render(request ,'line_register.html' ,contents )
else:
#實現狀態保持:oauth_line_user.user代表從oauth_line_user中找出對應的用戶模型類對象
login(request ,oauth_line_user.user )
#重定向到指定頁面:state
if state == '/':
response = redirect(reverse('contents:index'))
else:
response = redirect(state)
#將用戶登入資訊寫入到cookies
response.set_cookie('username' ,oauth_line_user.user.username ,constants.LOGIN_COOKIE_EXPIRES )
response.set_cookie('photo_url' ,oauth_line_user.photo_url ,constants.LOGIN_COOKIE_EXPIRES )
#用戶登錄成功後，同樣商品將cookies購物車數據覆蓋寫入redis
response = merge_carts_cookies_redis(request, oauth_line_user.user, response)
#返回響應
return response
def get(self, request):
"""处理QQ登录回调的业务逻辑"""
# 获取code
code = request.GET.get('code')
if not code:
return http.HttpResponseForbidden('获取code失败')
# 创建工具对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
try:
# 使用code获取access_token
access_token = oauth.get_access_token(code)
# 使用access_token获取openid
openid = oauth.get_open_id(access_token)
except Exception as e:
logger.error(e)
return http.HttpResponseServerError('OAuth2.0认证失败')
# 使用openid判断该QQ用户是否绑定过美多商城的用户
try:
oauth_user = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
# openid未绑定美多商城用户
access_token_openid = generate_access_token(openid)
context = {'access_token_openid': access_token_openid}
return render(request, 'oauth_callback.html', context)
else:
# openid已绑定美多商城用户:oauth_user.user表示从QQ登陆模型类对象中找到对应的用户模型类对象
login(request, oauth_user.user)
# 重定向到state:从哪来，QQ登录完之后回哪而去
next = request.GET.get('state')
response = redirect(next)
# 将用户名写入到cookies中
response.set_cookie('username',
oauth_user.user.username,
max_age=3600 * 24 * 15)
# 用户登录成功，合并cookie购物车到redis购物车
response = merge_carts_cookies_redis(request=request,
user=oauth_user.user,
response=response)
# 响应QQ登录结果
return response
def get(self, request):
# 接收参数
code = request.GET.get('code')
# 检验参数
if not code:
return JsonResponse({
'code': 400,
'errmsg': '缺少code参数'
})
# 处理数据
# 创建oauth工具类，传入code，转化成access_code,再向qq服务器请求openid
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
try:
# 使用oauth类对象的方法获取access_code
access_token = oauth.get_access_token(code)
# 使用oauth类对象的方法请求qq服务器获取openid
openid = oauth.get_open_id(access_token)
except Exception as e:
logger.error(e)
return JsonResponse({
'code': 400,
'errmsg': 'oauth2.0认证失败，获取用户qq认证消息失败'
})
try:
# 如果存在openid，则获取oauth的外键对象，表明用户已经注册并绑定了qq
# 状态保持
oauth_qq = OAuthQQUser.objects.get(openid=openid)
user = oauth_qq.user
login(request, user)
response = JsonResponse({
'code': 0,
'errmsg': 'ok',
})
response.set_cookie('username',
user.username,
max_age=3600 * 24 * 14)
return response
except Exception as e:
# 加密openid传给用户
access_token = generate_access_token(openid)
return JsonResponse({
'access_token': access_token
})
def get(self, request):
"""Oauth2.0认证"""
# 接收Authorization Code
code = request.GET.get('code')
if not code:
return http.HttpResponseForbidden('缺少必传参数')
# 创建工具对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
try:
# 携带code向qq服务器请求access_token
access_token = oauth.get_access_token(code)
# 携带access_token去请求openid
openid = oauth.get_open_id(access_token)
except Exception as e:
logger.error(e)
return http.HttpResponseForbidden('OAuth2.0认证失败')
# 使用openID去判断用户是否存在
try:
oauth_user = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
# 用户不存在
access_token = generate_access_token(openid)
# 拿到access_token，渲染到模板中返回
context = {'access_token': access_token}
return render(request, 'oauth_callback.html', context)
pass
else:
# 用户存在
# 根据外键，获取对应的QQ用户
user = oauth_user.user
# 实现状态保持
login(request, user)
# 创建重定向到首页
response = redirect(reverse('contents:index'))
# 写入cookie,15天
response.set_cookie('username',
user.username,
max_age=3600 * 24 * 15)
# 返回响应
return response
def get(self, request):
"""Oauth2.0认证"""
# 提取code请求参数
code = request.GET.get('code')
if not code:
return http.HttpResponseForbidden('缺少code')
# 创建工具对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID, client_secret=settings.QQ_CLIENT_SECRET, redirect_uri=settings.QQ_REDIRECT_URI)
try:
# 使用code向QQ服务器请求access_token
access_token = oauth.get_access_token(code)
except Exception:
logger.error('向QQ服务器请求access_token失败')
return http.HttpResponseServerError('OAuth2.0认证失败')
try:
# 使用access_token向QQ服务器请求openid
openid = oauth.get_open_id(access_token)
except Exception:
logger.error('向QQ服务器请求openid失败')
return http.HttpResponseServerError('OAuth2.0认证失败')
try:
oauth_user = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
# 如果openid没绑定美多商城用户
access_token_openid = generate_access_token(openid)
context = {'access_token_openid': access_token_openid}
return render(request, 'oauth_callback.html', context)
else:
# 如果openid已绑定美多商城用户
# 实现状态保持
qq_user = oauth_user.user
login(request, qq_user)
# 响应结果
next = request.GET.get('state')
response = redirect(next)
# 登录时用户名写入到cookie，有效期15天
response.set_cookie('username', qq_user.username, max_age=3600 * 24 * 15)
# 若用户登录成功，合并cookie中的购物车
merge_carts_cookies_redis(request=request, user=qq_user, response=response)
return response
def get(self, request):
# 接收参数
code = request.GET.get('code')
if not code:
return JsonResponse({'code': 400, 'errmsg': '缺少code参数'})
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
try:
# 获取access token
access_token = oauth.get_access_token(code)
# 获取openid
openid = oauth.get_open_id(access_token)
except Exception as e:
print(e)
logger.error(e)
return JsonResponse({'code': 400, 'errmsg': '认证失败'})
try:
oauth_qq = OAuthQQUser.objects.get(openid=openid)
except Exception as e:
# openid 没有绑定商城用户
access_token = generate_access_token(openid)
return JsonResponse({
'code': 300,
'errmsg': 'ok',
'access_token': access_token
})
user = oauth_qq.user
login(request, user)
response = JsonResponse({'code': 0, 'errmsg': 'ok'})
response.set_cookie('username', user.username, max_age=3600 * 24 * 14)
# 合并购物车
response = merge_cart_cookie_to_redis(request, user, response)
return response
def get(self, request):
code = request.GET.get('code')
if not code:
return http.HttpResponseForbidden('获取code失败')
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
try:
# 使用code获取access_token
access_token = oauth.get_access_token(code)
# 使用access_token获取openid
openid = oauth.get_open_id(access_token)
except Exception as e:
logger.error(e)
return http.HttpResponseServerError('OAuth2.0认证失败')
# 使用openid判断该QQ用户是否绑定过美多商城的用户
try:
oauth_user = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
# openid未绑定用户
access_token_openid = generate_access_token(openid)
context = {'access_token_openid': access_token_openid}
return render(request, 'oauth_callback.html', context)
else:
# openid已绑定用户
login(request, oauth_user.user)
# 重定向到state
next = request.GET.get('state')
response = redirect(next)
# 为了实现首页右上角展示用户名信息
response.set_cookie('username',
oauth_user.user.username,
max_age=3600 * 24 * 15)
# 用户登录成功,合并cookie购物车到Redis购物车
response = merge_cart_cookies_redis(request=request,
user=oauth_user.user,
response=response)
return response
def get(self, request):
code = request.GET.get('code')
if not code:
return http.HttpResponseForbidden('缺少code')
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI) # state只需要携带一次
try:
access_token = oauth.get_access_token(code)
openid = oauth.get_open_id(access_token)
except Exception as e:
logger.error(e)
return http.HttpResponseServerError('OAuth2.0认证失败')
try:
# 查询是否绑定
oauth_qq_user = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
# 如果openid没绑定美多商城用户
# 加密的openid
access_token_openid = generate_access_token(openid)
context = {'access_token_openid': access_token_openid}
# oauth_callback.html绑定用户的界面
return render(request, 'oauth_callback.html', context)
else:
# 如果openid已绑定美多商城用户
login(request, oauth_qq_user.user)
# 哪里点击的qq登录回哪里
next_url = request.GET.get('state')
response = redirect(next_url)
response.set_cookie('username',
oauth_qq_user.user.username,
max_age=3600 * 24 * 15)
response = merge_cart_cookie_to_redis(request=request,
user=oauth_qq_user.user,
response=response)
return response
def get(self, request):
code = request.GET.get('code')
if not code:
# 判断 code 参数是否存在
return JsonResponse({'code': 400, 'errmsg': '缺少code参数'})
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI,
state=next)
try:
# 携带 code 向 QQ服务器 请求 access_token
access_token = oauth.get_access_token(code)
# 携带 access_token 向 QQ服务器 请求 openid
openid = oauth.get_open_id(access_token)
except Exception as e:
# 如果上面获取 openid 出错, 则验证失败
logger.error(e)
# 返回结果
return JsonResponse({
'code': 400,
'errmsg': 'oauth2.0认证失败, 即获取qq信息失败'
})
# 判断用户是否绑定过qq
try:
open_result = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
# 如果 openid 没绑定美多商城用户,进入这里:
# 调用我们自定义的方法, 对 openid 进行加密
# 把 openid 变为 access_token
access_token = generate_access_token(openid)
# 把 access_token 返回给前端
# 注意: 这里一定不能返回 0 的状态码. 否则不能进行绑定页面
return JsonResponse({
'code': 300,
'errmsg': 'ok',
'access_token': access_token
})
else:
# 绑定的操作
user = open_result.user
# 实现状态保持
login(request, user)
# 创建重定向到主页的对象
response = JsonResponse({'code': 0, 'errmsg': 'ok'})
# 将用户信息写入到 cookie 中，有效期14天
response.set_cookie('username',
user.username,
max_age=3600 * 24 * 14)
response = merge_cart_cookie_to_redis(request=request,
user=user,
response=response)
return response
