예제 #1
0
    def post(self,request):

        # 接收参数
        mobile = request.POST.get('mobile')
        password = request.POST.get('password')
        sms_code = request.POST.get('sms_code')


        # 校验参数
        if not all([mobile,password,sms_code]):
            return http.HttpResponseForbidden('缺少必传参数')
        if not re.match(r'^1[3-9]\d{9}',mobile):
            return http.HttpResponseForbidden('请输入正确的手机号码')
        if not re.match(r'^[0-9a-zA-Z_]{8,20}',password):
            return http.HttpResponseForbidden('请输入8-20位的密码')

        # 验证短信验证码
        redis_conn = get_redis_connection('sms_code')
        redis_sms_code = redis_conn.get('sms_%s' % mobile)

        if redis_sms_code is None:
            return render(request, 'oauth_callback.html', {'sms_code_errmsg': '无效的短信验证码'})


        if sms_code.lower() != redis_sms_code.decode().lower():
            return render(request, 'oauth_callback.html', {'sms_code_errmsg': '输入短信验证码有误'})

        # 取出openid
        openid = request.POST.get('openid')
        # 解密
        openid_dict = SecretOauth().loads(openid)
        openid = openid_dict.get('openid')

        # 判断该手机号是否存在
        try:
            user = User.objects.get(mobile=mobile)
        except:
            # 如果不存在 则创建
            user = User.objects.create_user(username=mobile,password=password,mobile=mobile)
        else:
            # 如果存在 则校验密码
            if not user.check_password(password):
                return http.HttpResponseForbidden('手机号已经存在或密码错误')
        # 将用户和openid绑定
        OAuthSinaUser.objects.create(
            uid=openid,
            user=user,
        )

        # 状态保持
        login(request,user)

        # 重定向到用户原先所在的位置页面
        response = redirect(reverse('contents:index'))

        # 将用户名写入cookie
        response.set_cookie('username',user.username,max_age=3600*24*15)

        # 响应结果
        return response
예제 #2
0
파일: views.py 프로젝트: c0der1der/meiduo
    def get(self, request, username):
        # 1.接收参数
        image_code = request.GET.get('image_code')
        uuid = request.GET.get('image_code_id')

        # 2.校验用户名 和 图形验证码
        try:
            user = User.objects.get(username=username)
        except User.DoesNotExist:
            return http.JsonResponse({'status': 5004})
        img_client = get_redis_connection('verify_image_code')
        redis_img_code = img_client.get('img_%s' % uuid)

        if image_code.lower() != redis_img_code.decode().lower():
            return http.JsonResponse({'status': 5001})

        # 生成随机64位码字符串 存入redis 为下次发短信提交做准备
        mobile = user.mobile
        random_str = generat_csrf()

        img_client.setex('random_%s' % mobile, 300, random_str)

        access_token = SecretOauth().dumps(random_str)

        # 3.返回响应
        return http.JsonResponse({
            'status': 5000,
            "mobile": mobile,
            "access_token": access_token
        })
예제 #3
0
    def post(self, request, user_id):
        data = request.body.decode()
        data_dict = json.loads(data)
        password = data_dict.get('password')
        password2 = data_dict.get('password2')
        access_token = data_dict.get('access_token')

        if not all([access_token, password, password2]):
            return http.HttpResponseForbidden('填写数据不完整')
        if password != password2:
            return http.HttpResponseForbidden('两个密码不一致')

        user_dict = SecretOauth().loads(access_token)
        if user_dict is None:
            return http.JsonResponse({{'status': 400, 'errmsg': '参数错误'}})

        if int(user_id) != user_dict['user_id']:
            return http.JsonResponse({{'status': 400, 'errmsg': '用户不存在'}})

        try:
            user = User.objects.get(id=user_id)
        except:
            return http.JsonResponse({'status': 400, 'errmsg': '用户不匹配'})
        user.set_password(password)
        user.save()
        return http.JsonResponse({'status': RETCODE.OK, 'errmsg': '修改密码成功'})
예제 #4
0
    def get(self, request, username):
        sms_code = request.GET.get('sms_code')
        try:
            user = User.objects.get(username=username)
        except:
            return http.JsonResponse({'status': 400, 'errmsg': '用户名错误'})

        # 短信验证码
        # 1.读取redis中的短信验证码
        redis_cli = get_redis_connection('sms_code')
        sms_code_redis = redis_cli.get(user.mobile)
        # 2.判断是否过期
        if sms_code_redis is None:
            return http.HttpResponseForbidden('短信验证码已经过期')
        # 3.删除短信验证码,不可以使用第二次
        redis_cli.delete(user.mobile)
        redis_cli.delete(user.mobile + '_flag')
        # 4.判断是否正确
        if sms_code_redis.decode() != sms_code:
            return http.HttpResponseForbidden('短信验证码错误')

        json_str = SecretOauth().dumps({
            "user_id": user.id,
            'mobile': user.mobile
        })
        return http.JsonResponse({
            'user_id': user.id,
            'access_token': json_str
        })
예제 #5
0
    def get(self, request):
        access_token = request.GET.get('access_token')
        user_dict = SecretOauth().loads(access_token)

        if user_dict is None:
            return http.JsonResponse({'status': 400, 'errmsg': '参数不全'})
        mobile = user_dict['mobile']
        try:
            User.objects.get(mobile=mobile)
        except:
            return http.JsonResponse({'status': 400, 'errmsg': '手机号不存在'})

        # 验证
        redis_cli_sms = get_redis_connection('sms_code')
        # 是否60秒内
        if redis_cli_sms.get(mobile + '_flag') is not None:
            return http.JsonResponse({
                'status': 400,
                'errmsg': '发送短信太频繁,请稍候再发'
            })

        # 处理
        # 1.生成随机6位数
        sms_code = '%06d' % random.randint(0, 999999)
        print(sms_code)
        # 2.优化:使用管道
        redis_pl = redis_cli_sms.pipeline()
        redis_pl.setex(mobile, contants.SMS_CODE_REDIS_EXPIRE, sms_code)
        redis_pl.setex(mobile + '_flag', contants.SEND_SMS_CODE_INTERVAL, 1)
        redis_pl.execute()
        # 3.发短信
        # 通过delay调用,可以将任务加到队列中,交给celery去执行
        ccp_send_sms_code.delay(mobile, sms_code)

        return http.JsonResponse({'status': RETCODE.OK, 'errmsg': 'OK'})
예제 #6
0
    def get(self, request, username):
        # 1.接收参数
        uuid = request.GET.get('image_code_id')
        image_code = request.GET.get('text')

        # 2.图形验证码是否正确
        # 2.1从redis中读取之前保存的图形验证码文本
        redis_cli_image = get_redis_connection('verify_image_code')
        image_code_redis = redis_cli_image.get('img_%s' % uuid)
        # 2.2如果redis中的数据过期则提示
        if image_code_redis is None:
            return http.JsonResponse({
                'status': 400,
                'errmsg': '图形验证码已过期,点击图片换一个'
            })
        # 2.3立即删除redis中图形验证码,表示这个值不能使用第二次
        redis_cli_image.delete(uuid)
        # 2.4对比图形验证码:不区分大小写
        if image_code_redis.decode().lower() != image_code.lower():
            return http.JsonResponse({'status': 400, 'errmsg': '图形验证码错误'})
        try:
            user = User.objects.get(username=username)
        except Exception as e:
            return http.JsonResponse({'status': 404, 'errmsg': '用户名错误'})

        # 处理
        json_str = SecretOauth().dumps({
            "user_id": user.id,
            'mobile': user.mobile
        })
        return http.JsonResponse({
            'mobile': user.mobile,
            'access_token': json_str
        })
예제 #7
0
    def post(self,request):
        # 1.解析参数
        mobile = request.POST.get('mobile')
        pwd = request.POST.get('password')
        sms_code = request.POST.get('sms_code')
        openid = request.POST.get('openid')

        if openid is None:
            return http.HttpResponseForbidden('openid失效了')
        from utils.secret import SecretOauth
        openid = SecretOauth().loads(openid).get('openid')

        
        # 2.校验  判空 正则 图形 短信验证码

        # 3.校验mobile是否存在
        try:
            user = User.objects.get(mobile=mobile)
            if not user.check_password(pwd):
                return render(request,'oauth_callback.html', {'errmsg':"用户名或密码不正确"})
        except Exception as e:
            user = User.objects.create_user(username=mobile, password=pwd, mobile=mobile)
        # 4.绑定openid
        oauth_user = OAuthQQUser.objects.create(openid=openid, user=user)
        # 5.保持登陆状态 set_cookie 重定向到首页
        login(request, oauth_user.user)
        response = redirect(reverse('contents:index'))
        response.set_cookie('username', user.username, max_age=24*30*3600)
        return response
예제 #8
0
def is_bind_openid(request, openid):
    # 如果绑定了
    try:
        oauth_user = OAuthQQUser.objects.get(openid=openid)

    except Exception as e:
        logger.error(e)
        # 没有绑定了-->重定向到绑定页面
        secret_openid = SecretOauth().dumps({'openid': openid})
        context = {
            'openid': secret_openid
        }
        return render(request, 'oauth_callback.html', context)

    else:
        # 绑定了-保持登录状态->重定向到首页-->设置cookie username
        qq_user = oauth_user.user
        login(request, qq_user)

        # 响应结果
        response = redirect(reverse('contents:index'))

        # 登录时用户名写入到cookie,有效期15天
        response.set_cookie('username', qq_user.username, constants.USERNAME_EXPIRE_TIME)

        return response
예제 #9
0
    def put(self,request):
        #取出请求参数中的email
        json_str = request.body.decode()
        json_dict = json.loads(json_str)
        email = json_dict.get('email')
        #校验email格式是否满足要求
        # if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
        #     return http.HttpResponseForbidden('参数email有误')

        #保存email
        try :
            request.user.email = email
            request.user.save()

        except Exception as e:
            logger.error(e)
            return http.JsonResponse({'code': RETCODE.DBERR,'errmsg':'添加邮箱失败'})
        token_value = {
            'user_id': request.user.id,
            'email': email
        }

        from utils.secret import SecretOauth
        secret_str = SecretOauth().dumps(token_value)
        verify_url = settings.EMAIL_ACTIVE_URL + "?token=" + secret_str
        from celery_tasks.email.tasks import send_verify_email
        send_verify_email.delay(email, verify_url)

        # 4. 返回前端结果
        return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '添加邮箱成功'})
예제 #10
0
파일: views.py 프로젝트: libin-c/Meiduo
def is_bind_openid(openid, request):
    try:
        # openid = SecretOauth().loads(openid).get('openid')
        oauth_user = OAuthQQUser.objects.get(openid=openid)
    except Exception as e:
        logger.error(e)
        context = SecretOauth().dumps(openid)
        context = {'openid': context}

        return render(request, 'oauth_callback.html', context=context)
    else:
        # 如果openid已绑定美多商城用户
        # 实现状态保持
        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
예제 #11
0
def is_bind_openid(openid, request):
    try:
        # 1. 如果 数据表里面啊存在 --绑过了
        oauth_user = OAuthQQUser.objects.get(openid=openid)

    except Exception as e:
        # 2. 不存在 没有绑定过
        print(openid)
        openid = SecretOauth().dumps({'openid': openid})

        return render(request,
                      'oauth_callback.html',
                      context={'openid': openid})
    else:
        user = oauth_user.user

        # 保持登录状态
        login(request, user)

        # 设置首页用户名
        response = redirect(reverse('contents:index'))
        response.set_cookie('username', user.username, max_age=24 * 14 * 3600)
        # 重定向 首页

        return response
예제 #12
0
파일: views.py 프로젝트: c0der1der/meiduo
    def post(self, request, user_id):

        json_dict = json.loads(request.body.decode())
        password = json_dict.get('password')
        password2 = json_dict.get('password2')
        access_token = json_dict.get('access_token')

        if not all([password, password2, access_token]):
            return http.HttpResponseForbidden('参数不能为空!')

        # 解密前端 传入的
        loads_acces_token = SecretOauth().loads(access_token)

        if not re.match('^[0-9A-Za-z]{8,20}$', password):
            return http.HttpResponseForbidden('请输入8-20位的密码')
        # *   3.确认密码: ---------判空,判断是否相等
        if password2 != password:
            return http.HttpResponseForbidden('两次密码输入不一致')

        try:
            user = User.objects.get(id=user_id)
        except User.DoesNotExist:
            return http.JsonResponse({"status": 5002, 'message': "user_id有误!"})

        redis_client = get_redis_connection('verify_image_code')
        redis_random_token = redis_client.get('random_%s' % user.mobile)
        if loads_acces_token != redis_random_token.decode():
            return http.JsonResponse({"status": 5001, 'message': "token错误!"})

        # 更新密码
        user.set_password(password)
        user.save()

        return http.JsonResponse({"status": 5000, 'message': "密码设置成功!"})
예제 #13
0
파일: views.py 프로젝트: c0der1der/meiduo
    def get(self, request, mobile):
        sms_code = request.GET.get('sms_code')

        # 1.校验手机号
        try:
            user = User.objects.get(mobile=mobile)
        except User.DoesNotExist:
            return http.JsonResponse({"status": 5004})

        # 2.校验验证码
        sms_client = get_redis_connection('sms_code')
        redis_sms_code = sms_client.get('sms_%s' % mobile)

        if sms_code != redis_sms_code.decode():
            return http.JsonResponse({"status": 5001})

        # 3.返回正确的响应
        redis_client = get_redis_connection('verify_image_code')
        redis_random_token = redis_client.get('random_%s' % mobile)
        access_token = SecretOauth().dumps(redis_random_token.decode())

        return http.JsonResponse({
            "status": 5000,
            "user_id": user.id,
            "access_token": access_token
        })
예제 #14
0
    def put(self, request):
        # 1.接收 请求体非表单参数 json
        json_bytes = request.body
        json_str = json_bytes.decode()
        json_dict = json.loads(json_str)
        email = json_dict.get('email')

        # 2.正则校验邮箱
        if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
            return http.HttpResponseForbidden('参数email有误')

        # 3.修改 数据库中 email 值
        try:
            request.user.email = email
            request.user.save()
        except Exception as e:
            logger.error(e)
            return http.JsonResponse({'code': RETCODE.DBERR, 'errmsg': '添加邮箱失败'})

        # 自动发邮件(需要加密)
        token_value = {
            'user_id': request.user.id,
            'email': email
        }
        # 加密 --->对象方法SecretOauth()
        from utils.secret import SecretOauth
        secret_str = SecretOauth().dumps(token_value)
        # http://www.meiduo.site:8000/emails/verification/?token={%22user_id%22:%201,%20%22email%22:%20%[email protected]%22}
        verify_url = settings.EMAIL_ACTIVE_URL + "?token=" + secret_str
        from celery_tasks.email.tasks import send_verify_email
        send_verify_email.delay(email, verify_url)

        # 4.返回前端结果
        return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '添加邮箱成功'})
예제 #15
0
    def put(self, request):
        json_str = request.body.decode()
        # print(json_str)
        import json
        json_dict = json.loads(json_str)
        email = json_dict.get('email')
        # print(request.user)
        # print(email)
        # username= json_dict.get("username")
        # print(username)
        # request.user.email= email
        # request.user.save()
        # 校验
        if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
                        email):
            return http.HttpResponseForbidden('参数email有误')

        # 1.加密的数据
        data_dict = {'user_id': request.user.id, "email": request.user.email}
        # 2. 进行加密数据

        secret_data = SecretOauth().dumps(data_dict)

        # 发送邮件
        #subject 邮件标题
        # message 普通邮件正文,普通字符串
        # from_email 发件人
        # recipient_list 收件人列表
        # html_message 多媒体邮件正文,可以是html字符串

        subject = "美多商城邮箱验证"
        # subject = "ai爱直播"
        verify_url = settings.EMAIL_VERIFY_URL + '?token=' + secret_data

        html_message = '<p>尊敬的用户您好!</p>' \
                       '<p>感谢您使用美多商城。</p>' \
                       '<p>您的邮箱为:%s 。请点击此链接激活您的邮箱:</p>' \
                       '<p><a href="%s">%s</a></p>' % (email,verify_url, verify_url)
        # html_message = '<p>尊敬的用户赵博您好!</p>' \
        #                '<p>感谢您的注册</p>' \
        #                '<p>您的邮箱为:%s 。请点击此链接激活您的邮箱:</p>' \
        #                '<p><a href="http://www.sharesome.com">点此进入</a></p>' % (email)

        send_mail(subject,
                  message="1",
                  from_email="*****@*****.**",
                  recipient_list=[email],
                  html_message=html_message)

        # 保存数据库中
        try:
            User.objects.filter(username=request.user).update(email=email)
        except Exception as e:
            logger.error(e)
            return http.JsonResponse({
                'code': RETCODE.DBERR,
                'errmsg': '添加邮箱失败'
            })

        return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '添加邮箱成功'})
예제 #16
0
def generate_verify_emails_url(user):
    # 获取必传的两个参数 user_id email
    data_dict = {'user_id': user.id, 'email': user.email}
    # 加密数据
    from utils.secret import SecretOauth
    dumps_str = SecretOauth().dumps(data_dict)
    # 拼接完整的  带参数的链接
    return settings.EMAIL_ACTIVE_URL + '?token=' + dumps_str
예제 #17
0
    def post(self, request):

        # 1.接收解析参数
        mobile = request.POST.get('mobile')
        pwd = request.POST.get('password')
        sms_code = request.POST.get('sms_code')

        # 2. 校验---判断空, 正则---短信验证码
        openid = request.POST.get('openid')
        loads_openid_dict = SecretOauth().loads(openid)
        openid = loads_openid_dict.get('openid')
        if not openid:
            return render(request, 'oauth_callback.html',
                          {'openid_errmsg': "openid是无效的!"})

        # 3.判断用户是否存在
        try:
            user = User.objects.get(mobile=mobile)
        except User.DoesNotExist:
            # 5.不存在---创建新用户
            user = User.objects.create_user(username=mobile,
                                            mobile=mobile,
                                            password=pwd)
        else:
            # 4.存在---校验密码
            if not user.check_password(pwd):
                return render(request, 'oauth_callback.html',
                              {'account_errmsg': "用户名或密码错误!"})

        # 6. 绑定 openid
        try:
            qq_user = OAuthQQUser.objects.create(user=user, openid=openid)
        except Exception as e:
            return render(request, 'oauth_callback.html',
                          {'qq_login_errmsg': "qq绑定失败!"})

        # 7. 保持登录状态---设置cookie首页用户名----首页
        # 1.保持登录状态
        login(request, user)

        response = redirect(reverse('contents:index'))
        # 2. 设置cookie
        response.set_cookie('username', user.username, max_age=14 * 24 * 3600)

        # 3. 首页
        return response
예제 #18
0
    def post(self, request):
        # 1.接收参数 form POST
        mobile = request.POST.get('mobile')
        pwd = request.POST.get('password')
        sms_code = request.POST.get('sms_code')
        openid = request.POST.get('openid')


        # 2.校验--判空--正则--短信验证码
        # 判断参数是否齐全
        if not all([mobile, pwd]):
            return HttpResponseForbidden('参数不齐')
        # 判断手机号是否合法
        if not re.match(r'^1[3-9]\d{9}$', mobile):
            return HttpResponseForbidden('请输入正确的手机号码')
        # 判断密码是否合格
        if not re.match(r'^[0-9A-Za-z]{8,20}$', pwd):
            return HttpResponseForbidden('请输入8-20位的密码')
        # 判断短信验证码是否一致
        sms_code = request.POST.get('msg_code')
        # 6.1 从redis 中取出来
        redis_code_client = get_redis_connection('sms_code')
        redis_code = redis_code_client.get('sms_%s' % mobile)

        if redis_code is None:
            return render(request, 'oauth_callback.html', {'sms_code_errmsg': '无效的短信验证码'})
        if sms_code != redis_code.decode():
            return render(request, 'oauth_callback.html', {'sms_code_errmsg': '输入短信验证码有误'})
            # 判断openid是否有效:错误提示放在sms_code_errmsg位置

        # 3.解密--openid 校验
        openid = SecretOauth().loads(openid).get('openid')
        if not openid:
            return render(request, 'oauth_callback.html', {'openid_errmsg': '无效的openid'})


        # 4.判断用户是否存在 存在 user; 不存在新建user
        try:
            user = User.objects.get(mobile=mobile)
        except Exception as e:
            # 用户不存在 新建user
            user = User.objects.create(username=mobile, password=pwd, mobile=mobile)
        else:
            # 如果用户存在,检查密码     密码不正确
            if not user.check_password(pwd):
                return render(request, 'oauth_callback.html', {'account_errmsg': '用户名或密码错误'})

        # 5.user绑定openid
        try:
            OAuthQQUser.objects.create(openid=openid, user=user)
        except Exception as e:
            return render(request, 'oauth_callback.html', {'qq_login_errmsg': 'QQ登录失败'})

        # 6. 保持登录状态--重定向首页--set_cookie username
        login(request, user)
        response = redirect(reverse('contents:index'))
        response.set_cookie('username', user.username,constants.USERNAME_EXPIRE_TIME)
        return response
예제 #19
0
    def post(self, request):
        """美多商城用户绑定到openid"""
        # 接收参数
        mobile = request.POST.get('mobile')
        pwd = request.POST.get('password')
        sms_code_client = request.POST.get('sms_code')
        openid = request.POST.get('openid')

        # 校验参数
        # 判断参数是否齐全
        if not all([mobile, pwd, sms_code_client]):
            return http.HttpResponseForbidden('缺少必传参数')
        # 判断手机号是否合法
        if not re.match(r'^1[3-9]\d{9}$', mobile):
            return http.HttpResponseForbidden('请输入正确的手机号码')
        # 判断密码是否合格
        if not re.match(r'^[0-9A-Za-z]{8,20}$', pwd):
            return http.HttpResponseForbidden('请输入8-20位的密码')
        # 判断短信验证码是否一致
        redis_conn = get_redis_connection('sms_code')
        sms_code_server = redis_conn.get('sms_%s' % mobile)
        if sms_code_server is None:
            return render(request, 'oauth_callback.html', {'sms_code_errmsg': '无效的短信验证码'})
        if sms_code_client != sms_code_server.decode():
            return render(request, 'oauth_callback.html', {'sms_code_errmsg': '输入短信验证码有误'})
        # 解密出openid 再判断openid是否有效
        openid = SecretOauth().loads(openid).get('openid')
        if not openid:
            return render(request, 'oauth_callback.html', {'openid_errmsg': '无效的openid'})

        # 保存注册数据
        try:
            user = User.objects.get(mobile=mobile)
        except User.DoesNotExist:
            # 用户不存在,新建用户
            user = User.objects.create_user(username=mobile, password=pwd, mobile=mobile)
        else:
            # 如果用户存在,检查用户密码
            if not user.check_password(pwd):
                return render(request, 'oauth_callback.html', {'account_errmsg': '用户名或密码错误'})

        # 将用户绑定openid
        try:
            OAuthQQUser.objects.create(openid=openid, user=user)
        except DatabaseError:
            return render(request, 'oauth_callback.html', {'qq_login_errmsg': 'QQ登录失败'})

        # 实现状态保持
        login(request, user)

        # 响应绑定结果
        next = request.GET.get('state')
        response = redirect(next)

        # 登录时用户名写入到cookie,有效期15天
        response.set_cookie('username', user.username, max_age=3600 * 24 * 15)

        return response
예제 #20
0
def generate_verify_email_url(user):
    # 1.userid email
    data_dict = {'user_id':user.id,'email':user.email}
    # 2.加密
    secret_data = SecretOauth().dumps(data_dict)
    # 3.拼接连接
    verify_url = settings.EMAIL_ACTIVE_URL + '?token=' + secret_data
    # 4. 返回去
    return verify_url
예제 #21
0
파일: utils.py 프로젝트: Enticeyh/meiduo
def generate_verify_email_url(user):
    # http://www.meiduo.site:8000/emails/verification/
    #   ?token=eyJhbGciOiJIUzUxMiIsImlhdCI6MTU2NjE5ODk4MywiZXhwIjoxNTY2MjAyNTgzfQ.eyJ1c2VyX2lkIjo2LCJlbWFpbCI6ImxpdWNoZW5nZmVuZzY2NjZAMTYzLmNvbSJ9.okIKKAHjeskFild3EZeK3034N2r0vMb_tvUaVA7h4qPdfxmsDG4JvzXsTLl2_98Ln6rpWN4EmAdrdthZeG2DdQ

    # 1.获取 比传的 两个 参数 user_id email
    data_dict = {'user_id': user.id, 'email': user.email}
    # 2.加密 数据
    from utils.secret import SecretOauth
    dumps_str = SecretOauth().dumps(data_dict)

    # 3. 拼接完整的 带参数 的链接
    return settings.EMAIL_ACTIVE_URL + '?token=' + dumps_str
예제 #22
0
def generate_verify_email_url(user):
    # 1. user_id email
    dict_data = {'user_id': user.id, 'email': user.email}

    # 2.参数加密
    from utils.secret import SecretOauth
    secret_data = SecretOauth().dumps(dict_data)

    # 3.拼接 完整的路由
    verify_url = settings.EMAIL_ACTIVE_URL + '?token=' + secret_data

    return verify_url
예제 #23
0
def check_verify_email_token(token):
    # 解密
    from utils.secret import SecretOauth
    json_dict = SecretOauth().loads(token)
    # 校验用户是否存在  同时邮箱也匹配
    try:
        user = User.objects.get(id=json_dict['user_id'], email=json_dict['email'])
    except Exception as e:
        logger.error(e)
        return None
    else:
        return user
예제 #24
0
    def get(self, requests):
        # 接收参数
        code = requests.GET.get("code")

        # 微博连接
        from utils import sinaweibopy3
        client = sinaweibopy3.APIClient(
            # app_key: app_key值
            app_key=settings.APP_KEY,
            # app_secret:app_secret 值
            app_secret=settings.APP_SECRET,
            # redirect_uri : 回调地址
            redirect_uri=settings.REDIRECT_URL)
        # 通过code获得token
        result = client.request_access_token(code)
        access_token = result.access_token
        uid = result.uid

        uid = int(uid)
        # print(type(uid))
        try:
            user_sian = OAuthSinaUser.objects.get(uid=uid)
        except Exception as e:
            from utils.secret import SecretOauth
            uid = SecretOauth().dumps(uid)
            logger.error(e)
            return render(requests, 'sina_callback.html', context={'uid': uid})
        else:
            user = user_sian.user
            user = User.objects.get(id=user.id)
            login(requests, user)

            # response = http.JsonResponse({"status": 5000})
            response = redirect(reverse("users:index"))
            # response = http.HttpResponseRedirect(reverse('users:index'))
            # response = render(requests,"index.html",context={'uid': str(uid)})

            response.set_cookie("username",
                                user.username,
                                max_age=14 * 24 * 3600)
            # try:
            #     OAuthSinaUser.objects.create(uid=uid,user_id=user.id)
            # except Exception as e:
            #     logger.error(e)

            # login(request,user=user)

            # response = redirect(reverse("users:index"))
            # response = redirect(reverse("users:index"))
            # # 设置cookie
            # response.set_cookie("username", user.username, max_age=3600 * 24 * 15)

            return response
예제 #25
0
    def get(self, request):
        # 1.接收参数  request.GET
        token = request.GET.get('token')

        # 解密
        data_dict = SecretOauth().loads(token)

        user_id = data_dict.get('user_id')
        email = data_dict.get('email')

        # 2.校验
        try:
            user = User.objects.get(id=user_id, email=email)
        except Exception as e:
            print(e)
            return http.HttpResponseForbidden('token无效的!')

        # 3. 修改 email_active
        user.email_active = True
        user.save()

        # 4. 返回
        return redirect(reverse('users:info'))
예제 #26
0
def generate_verify_email_url(user):
    """
    :param user: 用户对象
    :return:
    """
    # 1.加密的数据
    data_dict = {'user_id': user.id, "email": user.email}

    # 2. 进行加密数据
    from utils.secret import SecretOauth
    secret_data = SecretOauth().dumps(data_dict)

    # 3. 返回拼接url
    active_url = settings.EMAIL_ACTIVE_URL + '?token=' + secret_data
    return active_url
예제 #27
0
 def get(self,request):
     # 1.接受参数
     token = request.GET.get('token')
     # 2.解密
     token_dict = SecretOauth().loads(token)
     # 3.校验userid  email
     try:
         user = User.objects.get(id=token_dict['user_id'],email=token_dict['email'])
     except Exception as e :
         return HttpResponseForbidden('无效的token')
     # 4.修改email_active
     user.email_active = True
     user.save()
     # 5.重定向到首页
     return redirect(reverse('contents:index'))
예제 #28
0
 def get(self,request):
     #1.接收参数
     token = request.GET.get('token')
     #2.解密
     from utils.secret import SecretOauth
     json_dict = SecretOauth().loads(token)
     #3.校验,用户是否存在,并且邮箱也正确
     try:
         user = User.objects.get(id=json_dict['user_id'],email=json_dict['email'])
     except Exception as e:
         logger.error(e)
         return http.HttpResponseForbidden('无效的token')
     user.email_active = True
     user.save()
     return redirect(reverse('users:info'))
예제 #29
0
파일: utils.py 프로젝트: libin-c/Meiduo
def generate_verify_email_url(user):
    '''
    传递user_id , email
    :param user:
    :return:
    '''
    # 1. 发送的数据
    data_dict = {'user_id': user.id, 'email': user.email}

    # 2. 加密数据
    secret_dict = SecretOauth().dumps(data_dict)

    # 3. 返回拼接的url
    verify_url = settings.EMAIL_ACTIVE_URL + '?token=' + secret_dict
    return verify_url
예제 #30
0
def check_verify_email_token(token):
    from utils.secret import SecretOauth
    try:
        token_dict = SecretOauth().loads(token)
    except:
        return None

    try:
        user = User.objects.get(id=token_dict['user_id'],
                                email=token_dict['email'])
    except Exception as e:
        logger.error(e)
        return None
    else:
        return user