def get(self, request): # 接收token access_token = request.GET.get('access_token') # 解密 token = CookieSecret.loads(access_token) # 验证token user_id = token['user_id'] user_mobile = token['mobile'] try: user = User.objects.get(id=user_id, mobile=user_mobile) except: return http.JsonResponse({'error': '数据错误'}, status=400) # 生成短信验证码 sms_code = '%06d' % randint(0, 999999) # 写入redis redis_conn = get_redis_connection('sms_code') redis_conn.setex('sms_%s' % user_mobile, 300, sms_code) # 异步发送短信验证码 ccp_send_sms_code.delay(user_mobile, sms_code) print("短信验证码是:", sms_code) # 响应结果 return http.JsonResponse({'message': 'ok'})
def get(self, request): """验证用户名""" # 接收查询字符串参数access_token access_token = request.GET.get('access_token') # 验证 user_info = json.loads(access_token) try: user = User.objects.get(mobile=user_info['mobile']) except User.DoesNotExist: return JsonResponse({'data': '用户不存在'}) # 发送短信验证码 # 防止用户不停刷新页面重发短信, 规定短信一分钟只能发一次 redis_conn = get_redis_connection('verify_code') pl = redis_conn.pipeline() flag = redis_conn.get('get_flag: %s' % user.mobile) if flag: return JsonResponse({'data': '访问过于频繁'}) sms_code = '%06d' % random.randint(0, 999999) # 打印出sms_code的值 logger.info(sms_code) # 保存短信验证码的值, 便于之后的校验 pl.setex('sms: %s' % user.mobile, constants.SMS_CODE_REDIS_EXPIRY, sms_code) # 发送验证码 # CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRY // 60], 1) pl.setex('get_flag: %s' % user.mobile, constants.SMS_CODE_REDIS_EXPIRY // 5, 1) pl.execute() ccp_send_sms_code.delay(user.mobile, sms_code) return JsonResponse({'message': '短信发送成功'})
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'})
def get(self, request, mobile): from random import randint sms_code = "%06d" % randint(0, 999999) # sms_code = randint(100000, 999999) print(sms_code) sms_redis_client = get_redis_connection('sms_code') # 1.取出标识 send_flag = sms_redis_client.get('send_flag_%s' % mobile) # 2.判断标识 if send_flag: return http.HttpResponseForbidden('短信发送频繁') # 1.实例化管道 pipeline = sms_redis_client.pipeline() # 2.将任务添加管道 pipeline.setex('send_flag_%s' % mobile, 60, 1) pipeline.setex("sms_%s" % mobile, 300, sms_code) # 3.实行管道' pipeline.execute() # 4.让第三方 容联云-给手机号-发送短信 from celery_tasks.sms.tasks import ccp_send_sms_code ccp_send_sms_code.delay(mobile, sms_code) # 5.告诉前端短信发送完毕 return Response({ 'success': True, 'sms_code': sms_code, 'message': 'OK' })
def get(self,request): # 接收参数 access_token = request.GET.get('access_token') # 解密 token = CookieSecret.loads(access_token) # 提取用户id和手机号 user_id = token['user_id'] user_mobile = token['mobile'] print("提出来的用户手机号:",user_mobile) # 校验用户的手机号是否存在 try: mobile = User.objects.get(id=user_id,mobile=user_mobile) except: return http.JsonResponse({'error':'手机号不正确'},status=400) # 生成短信验证码 from random import randint sms_code = '%06d' % randint(0,999999) # 写入redis中 redis_conn = get_redis_connection('sms_code') redis_conn.setex('sms_%s' % user_mobile,constants.SMS_CODE_REDIS_EXPIRES,sms_code) # 异步发送短信 ccp_send_sms_code.delay(user_mobile,sms_code) print("手机验证码是:", sms_code) # 响应结果 return http.JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
def send_sms_code(self, mobile): """ 发送验证码 :param mobile: 手机号 :return: """ # 链接数据库 redis_conn = get_redis_connection('verify_code') # 校验频繁发送 send_flag= redis_conn.get('sms_flag_%s' % mobile) if send_flag: return JsonResponse( {'code': response_code.RET.REQERR, 'errmsg': '请勿频繁操作'}) # 生成随机验证码 sms_code = '%06d' % random.randint(0, 999999) print(sms_code) # 保存短信验证码 pl = redis_conn.pipeline() pl.setex('sms_code_%s' % mobile, 300, sms_code) pl.setex('sms_flag_%s' % mobile, 60, 1) pl.execute() # 发送短信验证码 # celery 用delay 去调用,开启异步 ccp_send_sms_code.delay(mobile,sms_code) return JsonResponse( {'code': response_code.RET.OK, 'errmsg': 'OK'})
def get(self, request, mobile): # 检验标记 redis_conn = get_redis_connection("verify_code") send_flag = redis_conn.get("send_flag_%s" % mobile) # 检验是否有标记,有的话就是已经发过验证码 if send_flag: return JsonResponse({"code": "dgjhc", "errmsg": "已经发过验证码了"}) # 获取对象 image_code_client = request.GET.get("image_code") uuid = request.GET.get("uuid") # 判断参数是否齐全 if not all([image_code_client, uuid]): return JsonResponse({"code": RETCODE.NECESSARYPARAMERR, "errmsg": "缺少参数"}) # 从redis中取出uuid image_code_server = redis_conn.get('img_%s' % uuid) # 拿出后删除redis中验证码使失效 redis_conn.delete('img_%s' % uuid) # 检验验证码是否过期 if not image_code_server: return JsonResponse({"code": RETCODE.IMAGECODEERR, "errmsg": "图形验证码失效"}) # 比对图形验证码 image_code_server = image_code_server.decode() print(image_code_client,"\n",image_code_server) if image_code_client.lower() != image_code_server.lower(): return JsonResponse({"code": RETCODE.IMAGECODEERR, "errmsg": "图形验证码错误"}) # 生成短信验证码 sms_code = "%06d" % random.randint(0, 999999) logger.info(sms_code) print(sms_code) # 管道应用 p1 = redis_conn.pipeline() # 保存短信验证码 p1.setex("sms_%s" % mobile,60, sms_code) # 写入标记,设置60s过期 p1.setex("send_flag_%s" % mobile, contants.SMS_CODE_REDIS_EXPIRES, 1) # info(redis_conn.get("send_flag%s")%mobile) # 执行管道 p1.execute() # 发送短信验证码 ccp_send_sms_code.delay(mobile, sms_code) return JsonResponse({"code": RETCODE.OK, "errmsg": "短信发送成功"})
def get(self, reqeust, mobile): """ :param reqeust: 请求对象 :param mobile: 手机号 :return: JSON """ #1 创建连接到redis的对象 redis_conn = get_redis_connection('verify_code') #2 判断60秒内是否重复访问 send_flag = redis_conn.get('send_flag_%s' % mobile) if send_flag: return http.JsonResponse({'code': RETCODE.THROTTLINGERR, 'errmsg': '发送短信过于频繁'}) #3 接收参数 image_code_client = reqeust.GET.get('image_code') uuid = reqeust.GET.get('image_code_id') #4 验证参数 if not all([image_code_client,uuid]): return http.JsonResponse({'code': RETCODE.NECESSARYPARAMERR, 'errmsg': '缺少必传参数'}) #5 提取图形验证码 image_code_server = redis_conn.get('img_%s' % uuid) if image_code_server is None: # 图形验证码过期或者不存在 return http.JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图形验证码失效'}) #6 删除图形验证码,避免同一个图形验证码多次比较 try: redis_conn.delete('img_%s' % uuid) except Exception as e: logger.error(e) #7 对比图形验证码 image_code_server = image_code_server.decode() # bytes转字符串 if image_code_client.lower() != image_code_server.lower(): # 转小写后比较 return http.JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '输入图形验证码有误'}) #8 生成短信验证码:生成6位数验证码 sms_code = random.randint(0,999999) #sms_code = 6位随机验证码 logger.info(sms_code) print(sms_code) #9 创建Redis管道 pl = redis_conn.pipeline() # 将Redis请求添加到队列 pl.setex('sms_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code) pl.setex('send_flag_%s' % mobile, constants.SEND_SMS_CODE_INTERVAL, 1) # 执行请求 pl.execute() # Celery 异步发送短信验证码 ccp_send_sms_code.delay(mobile, sms_code) #11 响应结果 return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '发送短信成功'})
def get(self, request, mobile): # 1.解析校验参数--mobile 不用校验 uuid = request.GET.get('image_code_id') image_code = request.GET.get('image_code') # 2.校验图形验证码 如果正确 发送验证码, 不正确 直接返回 # 2.1 根据uuid 去redis数据库查询 图片验证码 from django_redis import get_redis_connection image_redis_client = get_redis_connection('verify_image_code') redis_img_code = image_redis_client.get('img_%s' % uuid) # 判断服务器返回的验证 if redis_img_code is None: return http.HttpResponseForbidden('图形验证码失效了') # 如果有值 删除redis服务器上的图形验证码 try: image_redis_client.delete('img_%s' % uuid) except Exception as e: logger.error(e) # 2.2 和前端传过来的进行做对比 # 千万注意: 在redis取出来的是 bytes 类型不能直接做对比 decode() if image_code.lower() != redis_img_code.decode().lower(): return http.HttpResponseForbidden({'输入图形验证码有误'}) # 3.生成短信验证码,redis-存储 from random import randint sms_code = "%06d" % randint(0, 999999) sms_redis_client = get_redis_connection('sms_code') # 4.让第三方 容联云-给手机号-发送短信 # from libs.yuntongxun.sms import CCP # # 手机号 验证码 过期时间5分钟 ,类型默认1 # CCP().send_template_sms(mobile, [sms_code, 5], 1) # # CCP().send_template_sms(mobile, [sms_code, 5], 1) # print("当前验证码是:", sms_code) # 发送短信验证码 # CCP().send_template_sms(mobile,[sms_code, constants.SMS_CODE_REDIS_EXPIRES // 60], constants.SEND_SMS_TEMPLATE_ID) # Celery异步发送短信验证码 from celery_tasks.sms.tasks import ccp_send_sms_code ccp_send_sms_code.delay(mobile, sms_code) print("当前验证码是:", sms_code) # (异步发短信) # 管道 pipeline = sms_redis_client.pipeline() pipeline.setex("sms_%s" % mobile, 300, sms_code) pipeline.setex('send_flag%s' % mobile, 60, 1) pipeline.execute() # 获取redis里面的标识 send_sms_flag = sms_redis_client.get('send_flag%s' % mobile) if send_sms_flag: return http.HttpResponseForbidden({'发送短信过于频繁'}) # 如果 倒计时标识 不在 # 5.告诉前端短信发送完毕 return JsonResponse({'code': '0', 'errmsg': '发送短信成功'})
def post(self, request): # 提取参数 # image_code = request.GET.get('image_code') # 用户填写的图片验证码 # uuid = request.GET.get('image_code_id') # 用户图形验证码的uuid # mobile = data = json.loads(request.body.decode()) mobile = data.get('mobile') text = data.get('text') # 用户输入的图形验证码 id = data.get('id') # 校验参数 if not all([mobile, id, text]): return JsonResponse({'code': 4101, 'errmsg': '缺少必要参数'}) # if not re.match(r'^[a-zA-Z0-9]{4}$', image_code): # return JsonResponse({'code': 4101, 'errmsg': '图形验证码格式有误'}) # if not re.match(r'^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$', uuid): # return JsonResponse({'code': 4101, 'errmsg': 'uuid格式有误'}) # 图形验证码校验 —— 根据uuid获取redis中的图形验证码,和用户填写的比对 conn = get_redis_connection('verify_code') # 2号 text1 = conn.get('img_%s' % id) # b"TYUP", redis客户端读取返回的数据统一是"字节"类型 # 为了保证图片验证码之后被使用一次,只需要读一次立刻删除 conn.delete('img_%s' % id) if not text1: # 如果图形验证码过期,text返回为空 return JsonResponse({'errno': 4101, 'errmsg': '图形验证码过期'}) # b"YUPO".decode() --> "YUPO" if text.lower() != text1.decode().lower(): # 统一转化小写对比,意味着忽略大小写 return JsonResponse({'errno': 4101, 'errmsg': '图形验证码错误!'}) # 业务数据处理 —— 发送短信 # 用户每次发送短信时,给该手机号标记一段唯一码,持续60s # 当用户再次发送短信时,判断是否有该唯一编码 flag = conn.get('send_flag_%s' % mobile) if flag: # 若有唯一编码,证明该手机号60s内发送过短信,直接返回 return JsonResponse({'errno': 4101, 'errmsg': '请勿频繁发送短信'}) # 生成固定6位数长度的0-9字符组成的验证码 sms_code = "%06d" % random.randrange(0, 999999) print('短信:', sms_code) # 把短信验证码写入redis conn.setex('sms_%s' % mobile, 300, sms_code) # 用户成功发送短信,给该手机号写入一段唯一编码 conn.setex('send_flag_%s' % mobile, 60, 1) # 使用redis的pipline功能,把多个redis指令打包执行 # 1.获取redis的pipeline对象 p = conn.pipeline() # 2.使用pipeline的对象方法实现调用指令 p.setex('sms_%s' % mobile, 300, sms_code) # 此处调用对象方法不会通信,只是把需求放入队列中 # 3.提交pipeline把指令通过网络一次性提交 p.execute() # 发送短信 ccp_send_sms_code.delay(mobile, sms_code) # 4、构建响应 return JsonResponse({'errno': 0, 'errmsg': 'ok'})
def get(self,request,mobile): # 接收uuid和用户输入的验证码 uuid = request.GET.get('image_code_id') image_code = request.GET.get('image_code') # 连接redis,根据uuid取出图片验证码 image_client_redis = get_redis_connection('verify_image_code') image_code_redis = image_client_redis.get('img_%s' % uuid) # 判None if image_code_redis is None: return http.JsonResponse({'code': "4001", 'errmsg': '图形验证码失效了'}) # 删除redis数据库中的uuid中的图片验证码 try: image_client_redis.delete('img_%s' % uuid) except Exception as e: logger.error(e) # 判断redis取出来的数据和用户输入的验证码是否相等 if image_code.lower() != image_code_redis.decode().lower(): return http.JsonResponse({'code': "4001", 'errmsg': '图形验证码有误'}) # 生成短信验证码 from random import randint sms_code = "%06d" % randint(0,999999) # 保存验证码到redis数据库 sms_client_redis = get_redis_connection('sms_code') # sms_client_redis.setex('sms_%s' % mobile ,300 ,sms_code) # 避免频繁发送短信验证码 send_flag = sms_client_redis.get('send_flag_%s' % mobile) if send_flag: return http.JsonResponse({'code': RETCODE.THROTTLINGERR, 'errmsg': '发送短信过于频繁'}) # 创建Redis管道 pl = sms_client_redis.pipeline() # 将Redis请求添加到队列 pl.setex('sms_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code) pl.setex('send_flag_%s' % mobile, constants.SEND_SMS_CODE_INTERVAL, 1) # 执行请求 pl.execute() # 使用第三方平台荣联云给手机号发短信 # from libs.yuntongxun.sms import CCP # CCP().send_template_sms(mobile,[sms_code,5],1) # Celery异步发送短信验证码 from celery_tasks.sms.tasks import ccp_send_sms_code ccp_send_sms_code.delay(mobile, sms_code) print("当前验证码是:",sms_code) print("手机号:",mobile) # 告诉前端 短信发送完毕 return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '发送短信成功!'})
def get(self, request, mobile): """ :param request: :param mobile: 手机号 :return: """ # 接收获取参数 image_code_client = request.GET.get('image_code') uuid = request.GET.get('uuid') # 校验参数 if not all([image_code_client, uuid]): return http.JsonResponse({'code': RETCODE.NECESSARYPARAMERR, 'errmsg': '缺少必传参数'}) # 连接到redis 获取验证码对象 redis_conn = get_redis_connection('verify_code') image_code_server = redis_conn.get('img_%s' % uuid) if image_code_server is None: # 图形验证码不存在或者过期 return http.JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图形验证码失效'}) # 删除已经验证过的验证码, 避免重复使用 try: redis_conn.delete('img_%s' % uuid) except Exception as e: logger.error(e) # 对比图片验证码 image_code_server = image_code_server.decode() if image_code_client.lower() != image_code_server.lower(): return http.JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图形验证码有误'}) # 生成6位数字短信验证码 sms_code = '%06d' % random.randint(0, 999999) # 保存验证码到redis中 # 创建redis对象 p1 = redis_conn.pipeline() p1.setex('sms_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code) p1.setex('send_flag_%s' % mobile, constants.SEND_SMS_CODE_INTERVAL, 1) p1.execute() # 发送验证码 # send_sms_code.delay(mobile, sms_code) # CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRES // 60], # constants.SEND_SMS_TEMPLATE_ID) # 异步发送验证码 ccp_send_sms_code.delay(mobile, sms_code) print(sms_code) # 相应发送结果 return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '发送短信成功'})
def get(self, request, mobile): # 获取redis对象 redis_conn = get_redis_connection('verify_code') # 获取redis中设置的判断 # 用于判断用户是否中60秒内重复发送短信 sms_flag = redis_conn.get('sms_flag_%s' % mobile) if sms_flag: return JsonResponse({'code': 404, 'errmsg': '发送短信过于频繁'}) # 获取用户输入的图形验证码 image_code_client = request.GET.get('image_code') # 获取该图形验证码的uuid uuid = request.GET.get('image_code_id') # 判断用户是否输入 if not all([image_code_client, uuid]): return JsonResponse({'code': 404, 'errmsg': '缺少必传参数'}) # 获取redis中的图形验证码用于与用户的进行对比 image_code_server = redis_conn.get('image_%s' % uuid) # 判断uuid是否过期 if not image_code_server: return JsonResponse({'code': 404, 'errmsg': '验证码已失效'}) # 对获取的验证码进行解码成字符串 image_code_server = image_code_server.decode() try: # 获取图形验证码后进行删除 redis_conn.delete('img_%s' % uuid) except Exception as e: logger.error(e) # 设置小写后,进行图形验证码对比 if image_code_server.lower() != image_code_client.lower(): return JsonResponse({'code': 404, 'errmsg': '验证码错误'}) # 生成6位数短信验证码 sms_code = '%06d' % randint(0, 999999) print(sms_code) # 设置管道,提高效率,减少握手次数 pl = redis_conn.pipeline() redis_conn.setex('sms_%s' % mobile, 300, sms_code) redis_conn.setex('sms_flag_%s' % mobile, 60, 1) # 执行管道 pl.execute() # CCP().send_template_sms(mobile, [sms_code, 5], 1) # 使用了celery程序进行发送短信---'异步' ccp_send_sms_code.delay(mobile, sms_code) return JsonResponse({'code': 0, 'errmsg': '发送成功'})
def get(self, request, mobile): # 创建连接到redis数据库的对象 redis_conn = get_redis_connection('verify_code') # 进入函数,获取redis里面的值,如果获取成功,说明没过60s time_redis = redis_conn.get('time_%s' % mobile) if time_redis: return JsonResponse({'code': 400, 'errmsg': '发送短信过于频繁'}) # 接受查询参数参数 image = request.GET.get('image_code') uuid = request.GET.get('image_code_id') # 校验参数 if not all([image, uuid]): return JsonResponse({"code": 400, "errmsg": '缺少必传参数'}) # 提取图片验证码 image_redis = redis_conn.get('img_%s' % uuid) # 验证验证码过期或不存在 if image_redis is None: return JsonResponse({'code': 400, 'errmsg': '图形验证码失效'}) # 删除redis中的图形验证码 try: redis_conn.delete('img_%s' % uuid) except Exception as e: logger.error(e) # 对比图形验证码 image_new = image_redis.decode('utf-8') if image.lower() != image_new.lower(): return JsonResponse({'code': 400, 'errmsg': '输入图形验证码有误'}) # 生成短信验证码 sms_code = '%06d' % random.randint(0, 999999) logger.info(sms_code) # 创建 Redis 管道 pl = redis_conn.pipeline() # 将 Redis 请求添加到队列 pl.setex('sms_%s' % mobile, 300, sms_code) pl.setex('time_%s' % mobile, 60, 1) # 执行请求, 这一步千万别忘了 pl.execute() # 保存短信验证码 # 短信验证码有效时间,300秒 # 发送短信验証码 ccp_send_sms_code.delay(mobile, sms_code) # return JsonResponse({'code':0,'errmsg':'短信发送成功'}) return JsonResponse({'code': 0, 'errmsg': 'ok'})
def get(self, request, mobile): # 在一开始,先对提取标志数据,判断相同的电话操作是否超过60秒了, 避免短信频繁操作 # 3.创建链接到redis的对象 redis_conn = get_redis_connection('verify_code') send_flag = redis_conn.get('send_flag_%s' % mobile) if send_flag: logger.warning('短信发送过于频繁') return http.JsonResponse({'code': 400, 'errmsg': '短信发送过于频繁'}) # 1.接受参数:图形验证码,uuid,电话号码 image_code_client = request.GET.get('image_code') uuid = request.GET.get('image_code_id') # 2.整体校验参数 if not all([image_code_client, uuid]): return http.JsonResponse({'code': 400, 'errmsg': '缺少比传参数'}) # 4.提取图形验证码 image_code_server = redis_conn.get('img_%s' % uuid) if image_code_server is None: return http.JsonResponse({'code': 400, 'errmsg': '图形验证码失效'}) # 5.删除redis的图形验证码,避免恶意测试图形验证码 try: redis_conn.delete('img_%s' % uuid) except Exception as e: logger.error(e) # 6.对比图形验证码 image_code_server = image_code_server.decode() if image_code_client.lower() != image_code_server.lower(): return http.JsonResponse({'code': 400, 'errmsg': '输入图形验证码有误'}) # 7.生成短信验证码:生成6位数验证码 sms_code = '%06d' % random.randint(0, 999999) logger.info(sms_code) # 通过管道方式优化客户端与redis通讯次数 # 创建管道 pl = redis_conn.pipeline() # 将redis请求添加到队列 # 8.保存短信验证码 pl.setex('sms_%s' % mobile, 300, sms_code) # 同时保存一个标记60秒, 用于避免短信轰炸 pl.setex('send_flag_%s' % mobile, 60, 1) # 执行请求 pl.execute() # 9.发送短信验证码 # CCP().send_template_sms(mobile,[sms_code,5],1) ccp_send_sms_code.delay(mobile, sms_code) # 10.响应结果 return http.JsonResponse({'code': 0, 'errmsg': '发送短信成功'})
def get(self, request, mobile): # '/sms_codes/' + this.mobile + '/ ?image_code=' + this.image_code + '&image_code_id=' + this.image_code_id; # 接受路径查询参数 用户输入的验证码 及 UUID image_code = request.GET.get('image_code') uuid = request.GET.get('image_code_id') # 连接 验证码的redis 数据库 image_redis_client = get_redis_connection('verify_image_code') redis_image_code = image_redis_client.get(uuid) # 判断 取出验证码是否为空, 如果为空则说明验证码过期 if redis_image_code is None: return http.JsonResponse({'code': "4001", 'errmsg': '图形验证码失效了'}) # 判断 取出验证码与输入验证码是否一直, 注意大小写的转换, 注意 从redis 数据库中取出的数据为 bytes 类型 if image_code.lower() != redis_image_code.decode().lower(): return http.JsonResponse({'code': "4001", 'errmsg': '输入图形验证码有误'}) # 删除 redis 数据库中的验证码 try: image_redis_client.delete(uuid) except Exception as e: logger.error(e) # 开始生成随机的六位数的验证码 sms_code = randint(100000, 999999) # 连接保存短信验证码的redis数据库 sms_redis_client = get_redis_connection('sms_code') # 判断是否已经发送过短信 send_flag = sms_redis_client.get('send_flag_%s' % mobile) if send_flag: return http.JsonResponse({'code': RETCODE.THROTTLINGERR, 'errmsg': '发送短信过于频繁'}) # 保存生成的短信验证码, 用手机号作为键 # sms_redis_client.setex(mobile, 300, sms_code) # 在redis中保存已经发送过短信的记录 # sms_redis_client.setex('send_flag_%s' % mobile, 60, 1) # redis 的管道操作 , 将多个要进行的操作装进管道中,一起进行操作 p1 = sms_redis_client.pipeline() p1.setex(mobile, 300, sms_code) p1.setex('send_flag_%s' % mobile, 60, 1) p1.execute() # 1. 发送短信 # CCP().send_template_sms(mobile, [sms_code, 5], 1) # 2. 调用celery 异步发送短信 ccp_send_sms_code.delay(mobile, sms_code) print('当前的验证码是:', sms_code) return http.JsonResponse({'code': '0', 'errmsg': '发送短信成功'})
def get(self, request, mobile): conn = get_redis_connection("verify_code") send_sms = conn.get('sms_code_%s' % mobile) if send_sms: return http.HttpResponseForbidden('短信验证码发送频繁') image_code_cilent = request.GET.get("image_code") uuid = request.GET.get("image_code_id") # 判断参数 if not all([image_code_cilent, uuid]): return http.JsonResponse({ 'code': RETCODE.IMAGECODEERR, 'errmsg': "缺少必传参数" }) # 教研参数 image_code = conn.get('img_%s' % uuid) if image_code is None: return http.JsonResponse({ 'code': RETCODE.IMAGECODEERR, 'errmsg': "图片验证码过期" }) try: conn.delete('img_%s' % uuid) except Exception as e: logger.error(e) image_code_server = image_code.decode() if image_code_cilent.lower() != image_code_server.lower(): return http.JsonResponse({ 'code': RETCODE.IMAGECODEERR, 'errmsg': "图片验证码错误" }) # 生成验证码 sms_code = '%06d' % random.randint(0, 999999) print(sms_code) # 保存到redis pl = conn.pipeline() pl.setex('sms_code_%s' % mobile, constants.IMAGE_CODE_REDIS_EXPIRES, sms_code) pl.setex('send_flag_%s' % mobile, constants.IMAGE_CODE_REDIS_EXPIRES, 1) pl.execute() # 发送验证码 # CCP().send_template_sms(mobile,[sms_code,5],constants.SMS_CDDE_ID) ccp_send_sms_code.delay(mobile, sms_code) return http.JsonResponse({'code': RETCODE.OK, 'error': 'ok'})
def get(self, request): access_token = request.GET.get("access_token") mobile = check_openid_signature(access_token) sms_code = "%06d" % random.randint(0, 999999) print(mobile, sms_code) logger.info(sms_code, "jafjsdkajfk") # 调用发短信 ccp_send_sms_code.delay(mobile, sms_code) # 存入redis redis_coon = get_redis_connection("verify_code") redis_coon.setex("sms_code_%s" % mobile, 60, sms_code) # 响应结果 return JsonResponse({"code": RETCODE.OK, "errmsg": "OK"})
def get(self, request, mobile): redis_conn = get_redis_connection('verify_code') time_redis = redis_conn.get('time_%s' % mobile) if time_redis: return JsonResponse({'code': 400, 'errmsg': '发送短信过于频繁'}) # 接收参数 image_code_c = request.GET.get('image_code') uuid = request.GET.get('image_code_id') # 校验参数 if not all([image_code_c, uuid]): return JsonResponse({'code': 400, 'errmsg': '缺少必传参数'}) # 创建连接到redis的对象 # 提取图片验证码 image_code_s = redis_conn.get('img_%s' % uuid) if image_code_s is None: return JsonResponse({'code': 400, 'errmsg': '图形验证码失效'}) try: redis_conn.delete('img_%s' % uuid) except Exception as e: logger.error(e) image_new = image_code_s.decode() # 对比图形验证码 if image_code_c.lower() != image_new.lower(): return JsonResponse({'code': 400, 'errmsg': '输入图形验证码有误'}) # 生成短信验证码 sms_code = '%06d' % random.randint(0, 999999) logger.info(sms_code) pl = redis_conn.pipeline() # 保存短信验证码 # 有效时间为300秒 pl.setex('sms_%s' % mobile, 300, sms_code) pl.setex('time_%s' % mobile, 60, 1) pl.execute() # 发送短信验证码 # CCP().send_template_sms(mobile,[sms_code,5],1) ccp_send_sms_code.delay(mobile, sms_code) return JsonResponse({'code': 0, 'errmsg': '发送短信成功'})
def get(self,request,mobile): #获取图形验证码的值 uuid = request.GET.get('image_code_id') image_code = request.GET.get('image_code') #获取数据库中图形验证码的值 image_redis_client = get_redis_connection('verify_image_code') redis_image_code = image_redis_client.get(uuid) #进行托图片验证码对比 if redis_image_code is None: return http.JsonResponse({'code':'4001','errmsg':'图形验证码失效了'}) #删除uuid try : image_redis_client.delete('uuid') except Exception as e: logger.error(e) if image_code.lower() != redis_image_code.decode().lower(): return http.JsonResponse({'code':'4001','errmsg':'输入图形验证码有误'}) #随机生成六位随机码 sms_cod = '%06d' % randint(0,999999) sms_redis_cilent = get_redis_connection('sms_code') sms_redis_cilent.setex(mobile,300,sms_cod) #获取频繁发送短信的标识 send_flag = sms_redis_cilent.get('send_flag_%s' % mobile) print(send_flag) if send_flag: return http.JsonResponse({'code': RETCODE.THROTTLINGERR, 'errmsg': '发送短信过于频繁'}) #重新写入send_flag的值,设置过期时间为60s #管道写法 p1 = sms_redis_cilent.pipeline() p1.setex('send_flag_%s' % mobile, 60, 1) p1.setex('sms_%s' % mobile, 60, sms_cod) p1.execute() # sms_redis_cilent.setex('send_flag_%s' % mobile,60,1) # sms_redis_cilent.setex('sms_%s' % mobile, 60, sms_cod) #通过第三方软件发送手机验证码 #异步触发任务 from celery_tasks.sms.tasks import ccp_send_sms_code ccp_send_sms_code.delay(mobile, sms_cod) # from libs.yuntongxun.sms import CCP # CCP().send_template_sms(18742078950,[sms_cod,5],1) print('当前验证码是',sms_cod) return http.JsonResponse({'code':'0','errmsg':'发送短信成功'})
def get(self, request, mobile): # GET http: // www.meiduo.site: 8000/sms_codes/18500000000/?image_code=IIJB&image_code_id=846b06a7-5766-4175-8d1f-c05625d0679c # *补充逻辑: 先判断用户是否频繁发送短信 redis_conn = get_redis_connection('verify_code') send_flag_mobile = redis_conn.get('send_flag_%s' % mobile) if send_flag_mobile: return http.JsonResponse({'code': 400, 'errmsg': '请勿频繁发送短信验证码'}) # 1. 接收参数 image_code_client = request.GET.get('image_code') image_code_id_client = request.GET.get('image_code_id') # 其实就是获取到uuid # 2. 校验参数 if not all([image_code_client, image_code_id_client]): return http.JsonResponse({'code': 400, 'errmsg': '缺少必传参数'}) # 3. 对比图形验证码,从redis数据库中取图形验证码 redis_conn = get_redis_connection('verify_code') redis_image_code = redis_conn.get('img_%s' % image_code_id_client) # 3.1 *小细节:提取可能没数据 if not redis_image_code: return http.JsonResponse({'code': 400, 'errmsg': '图形验证码失效'}) # 3.2 每提取一次立即删除redis数据库中的图形验证码,防止被恶意用户利用 redis_conn.delete('img_%s' % image_code_id_client) # 3.3 比对图形验证码 redis_image_code = redis_image_code.decode() if image_code_client.lower() != redis_image_code.lower(): return http.JsonResponse({'code': 400, 'errmsg': '图形验证码错误'}) # 3.4 生成随机短信验证码并保存到redis数据库,发送短信给客户手机 random_num = random.randint(0, 999999) sms_code = '%06d' % random_num logger.info(sms_code) # 小技巧:可以在终端输出,测试的时候绕过云通讯,查看生成的短信验证码 # redis_conn.setex('sms_%s' % mobile, 300, sms_code) # redis_conn.setex('send_flag_%s' % mobile, 60, 1) # *小细节:设置send_flag_mobile,标识,防止恶意用户再次刷新页面就可以频繁再次发送短信 # *小细节:创建pipline管道提升redis读写性能 pl = redis_conn.pipeline() pl.setex('sms_%s' % mobile, 300, sms_code) pl.setex('send_flag_%s' % mobile, 60, 1) pl.execute() # 3.5 发送短信 # CCP().send_template_sms(mobile, [sms_code, 5], 1) # *小细节: 由于客户收到短信可能是会有延迟,他会在页面一直等待,直到短信发送成功后,才开始计时60秒, # 用户交互-->美多商城-->发送短信-->响应结果 + 倒计时, 其中发送的短信是一个耗时操作。 # 所以,应该做异步处理,把相应结果+倒计时解耦出来,展示给用户应该是先计时,增强用户体验 # 异步函数.delay() ccp_send_sms_code.delay(mobile, sms_code) # 4.响应结果 return http.JsonResponse({'code': 0, 'errmsg': 'ok'})
def get(self, request, mobile): # 防止用户不停刷新页面重发短信, 规定短信一分钟只能发一次 redis_conn = get_redis_connection('verify_code') pl = redis_conn.pipeline() flag = redis_conn.get('get_flag: %s' % mobile) if flag: return JsonResponse({ 'code': RETCODE.THROTTLINGERR, 'errmsg': '访问过于频繁' }) image_code_cli = request.GET.get('image_code') uuid = request.GET.get('uuid') if all([image_code_cli, uuid]) is False: return JsonResponse({ 'code': RETCODE.NECESSARYPARAMERR, 'errmsg': '缺少必传参数' }) image_code_server = redis_conn.get('img: %s' % uuid) # 在数据库获取图片验证码后立即删掉, 防止一直输入相同的验证码,恶意点击发送短信 redis_conn.delete('img: %s' % uuid) if image_code_server is None or image_code_cli.lower( ) != image_code_server.decode().lower(): return JsonResponse({ 'code': RETCODE.IMAGECODEERR, 'errmsg': '图形验证码不正确' }) sms_code = '%06d' % random.randint(0, 999999) # 打印出sms_code的值 logger.info(sms_code) # 保存短信验证码的值, 便于之后的校验 pl.setex('sms: %s' % mobile, constants.SMS_CODE_REDIS_EXPIRY, sms_code) # 发送验证码 # CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRY // 60], 1) pl.setex('get_flag: %s' % mobile, constants.SMS_CODE_REDIS_EXPIRY // 5, 1) pl.execute() ccp_send_sms_code.delay(mobile, sms_code) return JsonResponse({'code': RETCODE.OK, 'errmsg': '短信发送成功'})
def get(self, request, mobile): # 获取传入参数 验证码,之前存入的uuid image_code_client = request.GET.get('image_code') uuid = request.GET.get('image_code_id') # 创建redis链接对象 redis_conn = get_redis_connection('verify_code') send_flag = redis_conn.get('send_flag_%s' % mobile) if send_flag: return JsonResponse({'code': 400, 'errmsg': '发送短信过于频繁'}) if not all([image_code_client, uuid]): return JsonResponse({'code': 400, 'errmsg': '缺少必传参数'}) # 获取uid对应的value(二进制) image_code_server = redis_conn.get('img_%s' % uuid) if image_code_server is None: return JsonResponse({'code': 400, 'errmsg': '图形验证码失效'}) try: redis_conn.delete('img_%s' % uuid) except Exception as e: logger.error(e) # 判断验证码是否正确 if image_code_client.lower() != image_code_server.decode().lower(): logger.info('输入图形验证码有误') return JsonResponse({'code': 400, 'errmsg': '输入图形验证码有误'}) sms_code = '%06d' % random.randint(1, 999999) # 日志输出验证码 logger.info('短信验证码:%s' % sms_code) # 管道创建 p1 = redis_conn.pipeline() # redis保存电话与验证码,保存倒计时时间 p1.setex('sms_%s' % mobile, 300, sms_code) p1.setex('send_flag_%s' % mobile, 300, 1) # 管道执行 p1.execute() # 发送短信 # CCP().send_template_sms(mobile, [sms_code, 5], 1) # 代码优化 celery 异步 ccp_send_sms_code.delay(mobile, sms_code) return JsonResponse({'code': 0, 'errmsg': '发送短信验证码成功'})
def get(self, reqeust, mobile): redis_conn = get_redis_connection('verify_code') send_flag = redis_conn.get('send_flag_%s' % mobile) if send_flag: return http.JsonResponse({'code': 400, 'errmsg': '发送短信过于频繁'}) image_code_client = reqeust.GET.get('image_code') uuid = reqeust.GET.get('image_code_id') if not all([image_code_client, uuid]): return http.JsonResponse({'code': 400, 'errmsg': '缺少必传参数'}) image_code_server = redis_conn.get('img_%s' % uuid) if image_code_server is None: return http.JsonResponse({'code': 400, 'errmsg': '图形验证码失效'}) try: redis_conn.delete('img_%s' % uuid) except Exception as e: logger.error(e) image_code_server = image_code_server.decode() if image_code_client.lower() != image_code_server.lower(): return http.JsonResponse({'code': 400, 'errmsg': '输入图形验证码有误'}) sms_code = '%06d' % random.randint(0, 999999) logger.info(sms_code) pl = redis_conn.pipeline() pl.setex('sms_code_%s' % mobile, 300, sms_code) pl.setex('send_flag_%s' % mobile, 60, 1) pl.execute() # 原来的写法: # CCP().send_template_sms(mobile, [sms_code, 5], 1) # 改为现在的写法, 注意: 这里的函数,调用的时候需要加: .delay() # ccp_send_sms_code.delay(mobile, sms_code) ccp_send_sms_code.delay(mobile, sms_code) return http.JsonResponse({'code': 0, 'errmsg': '发送短信成功'})
def get(self, request, mobile): # - 1.接收参数 解析参数 image_code = request.GET.get('image_code') uuid = request.GET.get('image_code_id') # - 2.校验图形验证码 redis # 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.HttpResponseForbidden('验证码输入有误!') # - 3.生成随机6位码 import random sms_code = random.randint(100000, 999999) # 4.使用 容联云 发送短信 sms_client = get_redis_connection('sms_code') # 获取redis里面的标识 send_sms_flag = sms_client.get('send_flag%s' % mobile) # 如果 倒计时的标识 在 if send_sms_flag: return http.HttpResponseForbidden('短信发送太频繁,请稍后!') # 如果 倒计时的标识 不在 # 使用异步任务 celery工具 发短信 from celery_tasks.sms.tasks import ccp_send_sms_code ccp_send_sms_code.delay(mobile, sms_code) print('项目里面的短信:', sms_code) # 5.存储短信 pipeline = sms_client.pipeline() pipeline.setex("sms_%s" % mobile, 300, sms_code) pipeline.setex('send_flag%s' % mobile, 60, 1) pipeline.execute() # - 6.返回响应对象a return http.JsonResponse({'code': '0', 'errmsg': '发送短信成功'})
def get(self,request): password = request.COOKIES.get('access_token') try: user = User.objects.get(password=password) # pbkdf2_sha256$36000$pYlJBXo314NN$ijot9M902M4+CMxN7qh6W9NW542JTfH9krY+Io/NnjM= except User.DoesNotExist: return JsonResponse({'code':RETCODE.DBERR,'errmsg':'无效密码'}) mobile = user.mobile redis_connet = get_redis_connection('verify_code') send_flag = redis_connet.get('send_flag_%s' % mobile) if send_flag: return JsonResponse({'code': RETCODE.THROTTLINGERR, 'errmsg': '发送短信过于频繁'}) import random sms_code = '%06d' % random.randint(0, 999999) logger.info(sms_code) pl = redis_connet.pipeline() pl.setex('sms_%s' % mobile, 300, sms_code) pl.setex('send_flag_%s' % mobile, 60, 1) pl.execute() ccp_send_sms_code.delay(mobile, sms_code) return JsonResponse({'code': RETCODE.OK, 'errmsg': '短信发送成功'})
def get(self, request, mobile): # 0.检验短信标志是否存在, 避免短信轰炸 # 需要先链接数据库, 提取短信标志, 才能判断 redis_conn = get_redis_connection('verify_code') send_flag = redis_conn.get('send_flag_%s' % mobile) if send_flag: return http.JsonResponse({'code': 400, 'errmsg': '短信发送过于频繁'}) # 1.获取参数 uuid = request.GET.get('image_code_id') image_code_client = request.GET.get('image_code') # 2.验证参数(整体验证, 单个验证) if not all([uuid, image_code_client]): return http.JsonResponse({'code': 400, 'errmsg': '参数有误'}) # 图形验证码检验(提取,删除,对比) # 提取 image_code_server = redis_conn.get('img_%s' % uuid) if image_code_server is None: return http.JsonResponse({'code': 400, 'errmsg': '图形码失效'}) # 删除 try: redis_conn.delete('img_%s' % uuid) except Exception as e: logger.error(e) # 对比 if image_code_client.lower() != image_code_server.decode().lower(): return http.JsonResponse({'code': 400, 'errmsg': '图形码验证失败'}) # 3.生成短信验证码 sms_code = '%d' % random.randint(100000, 999999) logger.info(sms_code) # 4.保存短信验证码 # 用管道pipeline pl = redis_conn.pipeline() pl.setex('sms_%s' % mobile, 300, sms_code) pl.setex('send_flag_%s' % mobile, 60, 1) pl.execute() # 5.发送短信验证码 #采用异步方案 ccp_send_sms_code.delay(mobile, sms_code) # 6.返回响应结果 return http.JsonResponse({'code': 200, 'errmsg': 'ok'})
def get(self, request): access_token = request.GET.get('access_token') user_dict = CookieSecret.loads(access_token) if user_dict is None: return JsonResponse({}, status=400) mobile = user_dict['mobile'] try: User.objects.get(mobile=mobile) except: return JsonResponse({}, status=400) # 验证 redis_cli_sms = get_redis_connection('sms_code') # 0.是否60秒内 if redis_cli_sms.get(mobile + '_flag') is not None: return JsonResponse({ 'code': RETCODE.SMSCODERR, 'errmsg': '发送短信太频繁,请稍候再发' }) # # 处理 # # 1.生成随机6位数 sms_code = '%06d' % random.randint(0, 999999) print(sms_code) # 优化:使用管道 redis_pl = redis_cli_sms.pipeline() redis_pl.setex(mobile, constants.SMS_CODE_EXPIRES, sms_code) redis_pl.setex(mobile + '_flag', constants.SMS_CODE_FLAG, 1) redis_pl.execute() # 3.发短信 # 通过delay调用,可以将任务加到队列中,交给celery去执行 from celery_tasks.sms.tasks import ccp_send_sms_code ccp_send_sms_code.delay(mobile, sms_code) # 响应 return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
def get(self, request, mobile): # 链接到redis数据库,获取手机号 redis_conn = get_redis_connection('verify_code') send_flag = redis_conn.get('send_flag_%s' % mobile) if send_flag: return http.JsonResponse({'code': 400, 'errmsg': '发送过于频繁'}) # 接受前端参数 image_code_client = request.GET.get('image_code') uuid = request.GET.get('image_code_id') # 整体校验 if not all([image_code_client, uuid]): return http.JsonResponse({'code': 400, 'errmsg': '缺少必要参数'}) # 获取图形验证码 image_code_server = redis_conn.get('img_%s' % uuid) # 图形验证码校验 if image_code_server is None: return http.JsonResponse({'code': 400, 'errmsg': '图形验证码失效'}) # 删除redis中图形验证码 try: redis_conn.delete('img_%s' % uuid) except Exception as error: logger.error(error) # 服务端图形验证码转换 image_code_server = image_code_server.decode() # 图形验证码对比 if image_code_client.lower() != image_code_server.lower(): return http.JsonResponse({'code': 400, 'errmsg': '输入有误'}) # 生成6位短信验证码 # sms_code = '%06d' % random.randint(0, 999999) sms_code = 123456 logger.info(sms_code) # 创建管道并执行 pl = redis_conn.pipeline() pl.setex('sms_%s' % mobile, 300, sms_code) pl.setex('send_flag_%s' % mobile, 60, 1) pl.execute() # 发送短信 # CCP().send_template_sms(mobile, [sms_code, 5], 1) ccp_send_sms_code.delay(mobile, sms_code) return http.JsonResponse({'code': 0, 'errmsg': '发送成功'})
def get(self, request, mobile): img_code_cli = request.GET.get('image_code') uuid = request.GET.get('image_code_id') if not all([uuid, img_code_cli]): return JsonResponse({'code': 400, 'errmsg': '参数获取不全'}) redis_conn = get_redis_connection('verify_code') img_code_server = redis_conn.get(f'img_{uuid}') if not img_code_server: return JsonResponse({'code': 400, 'errmsg': '验证码过期'}) try: redis_conn.delete(f'img_{uuid}') except Exception as e: logger.info(e) if img_code_cli.lower() != img_code_server.decode().lower(): return JsonResponse({'code': 400, 'errmsg': '验证码错误'}) if redis_conn.ttl(f'sms_{mobile}') > 240 and redis_conn.get( f'sms_{mobile}'): return JsonResponse({'code': 400, 'errmsg': '请勿频繁发送'}) sms_code = randomNumber() redis_conn.setex(f'sms_{mobile}', 300, sms_code) print(sms_code) # CCP().send_template_sms(mobile, (sms_code, 5), 1) ccp_send_sms_code.delay(mobile, sms_code) return JsonResponse({'code': 0, 'errmsg': '短信发送成功'})
def get(self, request, mobile): """ :param request: :param mobile:手机号 :return: JSON """ #校验是否已发送过短信验证码,避免重复发送 redis_conn = get_redis_connection('verify_code') send_flag = redis_conn.get('send_flag_%s' % mobile) # 查看数据是否存在, 如果存在, 说明60s没过, 返回 if send_flag: return http.JsonResponse({'code': 400, 'errmsg': '发送短信过于频繁'}) # 接受参数 image_code_client = request.GET.get('image_code') uuid = request.GET.get('image_code_id') # 参数校验 if not all([image_code_client, uuid]): return http.JsonResponse({'code': 400, 'errmsg': '缺少必传参数'}) # 链接redis库,提取图形验证码 redis_conn = get_redis_connection('verify_code') image_code_server = redis_conn.get('img_%s' % uuid) if image_code_server is None: # 图形验证码过期 return http.JsonResponse({'code': 400, 'errmsg': '图形验证码失效'}) # 删除图形验证码,避免恶意测试图形验证码 try: redis_conn.delete('img_%s' % uuid) except Exception as e: logger.error(e) # 对比图形验证码 image_code_server = image_code_server.decode() if image_code_client.lower() != image_code_server.lower(): return http.JsonResponse({'code': 400, 'errmsg': '输入图形验证码有误'}) # 生成短信验证码 sms_code = '%06d' % random.randint(0, 999999) logger.info(sms_code) #pipeline,减少客户端与redis的通信次数,降低往返延时 pl = redis_conn.pipeline() # 保存短信验证码,为了注册时校验 pl.setex('sms_%s' % mobile, 300, sms_code) #设置一个send_flag,用于访问接口时先校验是否存在,从而判断是否重复发送短信验证码 pl.setex('send_flag_%s' % mobile, 60, 1) #执行和redis的请求 pl.execute() # 调用celery发送短信验证码 ccp_send_sms_code.delay(mobile, sms_code) # 10. 响应结果 return http.JsonResponse({'code': 0, 'errmsg': '发送短信成功'})