def get_sms_code(): """ '{"mobile": "11111111111", "image_code": "AAAA", "image_code_id": "sfownegwefwfwefs"}' 1. 获取手机号| 图片验证码编号 | 图片验证码内容 2. 检验参数(是否符合规则, 是否存在) 3. 从redis中获取 真实值 4. 比对 5. 生成短信验证码或者错误提示 6. 告知发送结果 :return: json 数据 """ # 接收到的是 json 格式的字符串 # 1.获取参数 # params_dict = json.loads(request.data) # 但是这里不这么操作 params_dict = request.json # type: dict mobile = params_dict.get("mobile") image_code = params_dict.get("image_code") image_code_id = params_dict.get("image_code_id") # 2.校验参数 if not all([mobile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg="参数有误") # 检验手机号是否正确 if not re.match(r"1[35678]\d{9}", mobile): return jsonify(errno=RET.DBERR, errmsg="手机号格式不正确") try: real_image_code = redis_store.get( "ImageCodeID_" + image_code_id) # StrictRedis: redis_store except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据查询失败") if not real_image_code: return jsonify(errno=RET.NODATA, errmsg="图片验证码过期") if real_image_code.upper() != image_code.upper(): return jsonify(errno=RET.DATAERR, errmsg="验证码输入错误") # 3.生成短信验证码内容, 调用三方平台发送短信 sms_code_str = "{:06d}".format(random.randint(0, 999999)) current_app.logger.debug("短信验证码内容是: %s" % sms_code_str) # 发送短信验证码 result = CCP().send_template_sms( mobile, [sms_code_str, constants.SMS_CODE_REDIS_EXPIRES / 5], "1") # if result != 0: # # 代表发送不成功 # return jsonify(errno=RET.THIRDERR, errmsg="发送短信失败") # 保存短信验证码到 redis try: redis_store.setex("SMS_" + mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code_str) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据操作失败") # 4.返回提示信息 return jsonify(errno=RET.OK, errmsg="发送成功")
def send_sms_code(): ''' 发送短信的逻辑 1 获取参数:手机号,图片验证码内容,图片验证码的编号 2 校验参数(参数是否符合规则,判断是否有值 3 先从redis中取出验证码内容,与用户的验证码内容对比. 4 如果对比不一致,那么验证码输入错误. 5 如果一直,生成验证码内容 6 发送验证码 7 告知发送结果. :return: ''' # 1 获取参数:手机号,图片验证码内容,图片验证码的编号 params_dict = request.json mobile = params_dict.get("mobile", None) image_code = params_dict.get('image_code', None) image_code_id = params_dict.get("image_code_id", None) # 2 校验参数(参数是否符合规则,判断是否有值 if not all([mobile, image_code, image_code_id]): #没有值就返回错误 #{"errno":4100,"errmsg":"参数有无'} return jsonify(errno=RET.PARAMERR, errmsg="参数错误") #检测手机是欧服正确 if not re.match(r'1[35678]\d{9}$', mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号有错误") # 3 先从redis中取出验证码内容,与用户的验证码内容对比. try: real_image_code = redis_store.get("ImageCodeId_" + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmag="查询数据失败") if not real_image_code: return jsonify(errno=RET.NODATA, errmsg="图片验证码过期") # 4 如果对比不一致,那么验证码输入错误. if real_image_code.upper() != image_code.upper(): return jsonify(errno=RET.DBERR, errmsg="验证码输入错误") # 5 如果一直,生成验证码内容 #随机数字,保证数字长度为6为3,不够再前面不上0. sms_code_str = "%06d" % random.randint(0, 999999) current_app.logger.debug("短信验证码是%s" % sms_code_str) # 6 发送验证码 result = CCP().send_template_sms( mobile, [sms_code_str, constants.SMS_CODE_REDIS_EXPIRES / 60], 1) if result != 0: #代表发送不成功 return jsonify(errno=RET.THIRDERR, errmsg="发送短信失败") #保存验证码到redis中 try: redis_store.set('SMS_' + mobile, sms_code_str) redis_store.expire('SMS_' + mobile, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据存储错误") # 7 告知发送结果. return jsonify(errno=RET.OK, errmsg="发送成功")
def get_msg_code(): dict_data = request.json modile, image_code, image_code_id = dict_data.get("modile"), dict_data.get( "image_code"), dict_data.get("image_code_id") if not all([modile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg="参数不全") if not re.match(r"1[35678]\d{9}", modile): return jsonify(erron=RET.PARAMERR, errmsg="手机号格式不正确") try: real_image_code = redis_store.get("ImageCodeId_" + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(erron=RET.DBERR, errmsg="数据库查询失败") if not real_image_code: return jsonify(erron=RET.NODATA, errmsg="图片验证码已过期") if image_code.upper() != real_image_code.upper(): return jsonify(errno=RET.DATAERR, errmsg="图片验证码输入错误") sms_code_str = "%06d" % random.randint(0, 999999) result = CCP().send_template_sms(modile, [sms_code_str, 5], 1) if result != 0: return jsonify(errno=RET.THIRDERR, errmsg="第三方错误") try: redis_store.setex("sms_" + modile, constants.SMS_CODE_REDIS_EXPIRES, sms_code_str) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="手机验证码保存失败") return jsonify(errno=RET.OK, errmsg="发送成功")
def sms_code(): #"{'mobile':'13829494822','image_code':'asdf','image_code_id':uuid}" json_str = request.data.decode('utf-8') json_dict = json.loads(json_str) mobile = json_dict['mobile'] image_code_client = json_dict['image_code'] image_code_id = json_dict['image_code_id'] if not all([mobile, image_code_client, image_code_id]): return jsonify(errno=response_code.RET.PARAMERR, errmsg='缺少参数') if not re.match(r'^1[345678][0-9]{9}$', mobile): return jsonify(errno=response_code.RET.PARAMERR, errmsg='手机格式错误') try: image_code_server = redis_store.get('imageCoedId:' + image_code_id) except Exception as e: current_app.logger.erro(e) return jsonify(errno=response_code.RET.DBERR, errmsg='查询验证码失败') if not image_code_server: return jsonify(error=response_code.RET.NODATA, errmsg='图片验证码不存在') if image_code_server.lower() != image_code_client.lower(): return jsonify(error=response_code.RET.PARAMERR, errmsg='输入验证码错误') sms_code = '%06d' % random.randint(0, 999999) current_app.logger.debug(sms_code) result = CCP().send_template_sms(mobile, [sms_code, 5], 1) if result != 0: return jsonify(error=response_code.RET.THIRDERR, errmsg='发送验证码错误') try: redis_store.set('SMS:' + mobile, sms_code, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: return jsonify(error=response_code.RET.DBERR, errmsg='保存验证码失败') return jsonify(error=response_code.RET.OK, errmsg='发送验证码成功')
def send_sms_code(): """ 发送短信的逻辑 1.获取参数:手机号,图片验证码内容,图片验证码的编号(生成随机值) 2.校验参数(参数是否符合规则,判断是否有值) 3.先从redis中取出真实的验证码内容 4.与用户的验证码内容进行比较,如果不一致返回验证码输入错误 5.如果一致,生成验证码内容(随机数据) 6.发送短信验证码 7.告知发送结果 :return: """ '{"mobiel":"18811111111","image_code":"AAAA","image_code_id":"u23jksdhjfkjh2jh4jhdsj"}' # 1. params_dict = request.json mobile = params_dict.get("mobile") image_code = params_dict.get("image_code") image_code_id = params_dict.get("image_code_id") # 2 # 判断参数是否有值 if not all([mobile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg="参数有误") # 检验手机号是否正确 if not re.match('1[35678]\\d{9}', mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确") # 3 try: real_image_code = redis_store.get("ImageCodeId_" + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据查询失败") if not real_image_code: return jsonify(errno=RET.NODATA, errmsg="图片验证码已过期") # 4 if real_image_code.upper() != image_code.upper(): return jsonify(errno=RET.DATAERR, errmsg="验证码输入错误") # 5 sms_code_str = "%06d" % random.randint(0, 9999) current_app.logger.debug("贪玩蓝月提醒您,您的验证码是 %s" % sms_code_str) # 6 result = CCP().send_template_sms( mobile, [sms_code_str, constants.SMS_CODE_REDIS_EXPIRES / 5], "1") if result != 0: # 代表发送不成功 return jsonify(errno=RET.THIRDERR, errmsg="发送短信失败") # 保存验证码内容到redis try: redis_store.set("SMS_" + mobile, sms_code_str, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据保存失败") # 7. 告知发送结果 return jsonify(errno=RET.OK, errmsg="发送成功")
def sms_code(): """发送短信验证码 1.接受参数(手机号,图片验证码,图片验证码编号) 2.校验参数(判断参数是否存在,手机号是否合法) 3.查询服务器存储的图片验证码 4.跟客户端传入的图片验证码对比 5.如果对比成功,生成短信验证码数字 6.调用CCP()单例类封装的发送短信的方法,发送短信 7.将短信验证码存储到服务器(将来注册时要判断短信验证码是否正确) 8.响应发送短信验证码的结果 """ # 1.接受参数(手机号,图片验证码,图片验证码编号) # '{'mobile':'17600992168','image_code':1234,'image_code_id':'uuid'}' # json_str = request.data # json_dict = json.loads(json_str) json_dict = request.json mobile = json_dict.get('mobile') image_code_clinet = json_dict.get('image_code') image_code_id = json_dict.get('image_code_id') # 2.校验参数(判断参数是否存在,手机号是否合法) if not all([mobile, image_code_clinet, image_code_id]): # '{'errno':'0', 'errmsg':'OK'}' return jsonify(errno=response_code.RET.PARAMERR, errmsg='缺少参数') if not re.match(r'^1[345678][0-9]{9}$', mobile): return jsonify(errno=response_code.RET.PARAMERR, errmsg='手机号格式错误') # 3.查询服务器存储的图片验证码 try: image_code_server = redis_store.get('ImageCode:' + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=response_code.RET.DBERR, errmsg='查询图片验证码失败') if not image_code_server: return jsonify(errno=response_code.RET.NODATA, errmsg='图片验证码不存在') # 4.跟客户端传入的图片验证码对比 if image_code_server.lower() != image_code_clinet.lower(): return jsonify(errno=response_code.RET.PARAMERR, errmsg='输入验证码有误') # 5.如果对比成功,生成短信验证码数字 # '%06d' : 不够6位补0;比如,34--》000034 sms_code = '%06d' % random.randint(0, 999999) # 6.调用CCP()单例类封装的发送短信的方法,发送短信 result = CCP().send_template_sms(mobile, [sms_code, 5], 1) if result != 0: return jsonify(errno=response_code.RET.THIRDERR, errmsg='发送短信验证码失败') # 7.将短信验证码存储到服务器(将来注册时要判断短信验证码是否正确) try: redis_store.set('SMS:' + mobile, sms_code, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=response_code.RET.DBERR, errmsg='存储短信验证码失败') # 8.响应发送短信验证码的结果 return jsonify(errno=response_code.RET.OK, errmsg='发送短信验证码成功')
def get_sms_code(): """ 生产并发送短信验证码 1.获取参数:手机号,图片验证码id,图片验证码内容 2.判断是否有值,校验手机号 3.从redis中取出图片验证码内容,与用户传过来的图片验证码内容进行校验 4.生成短信验证码 5.发送短信验证码 6.将短信验证码内容存到redis中,记录验证码 7.返回响应 :return: """ # 1.获取参数:手机号,图片验证码id,图片验证码内容 params_dict = request.json mobile = params_dict["mobile"] image_code = params_dict["image_code"] image_code_id = params_dict["image_code_id"] # 2.判断是否有值,校验手机号 if not all([mobile, image_code_id, image_code]): return jsonify(errno=RET.PARAMERR, errmsg="参数不全") # 校验手机号 if not re.match(r"^1[345678]\d{9}$", mobile): return jsonify(errno=RET.DATAERR, errmsg="手机号不正确") # 3.从redis中取出图片验证码内容,与用户传过来的图片验证码内容进行校验 try: real_image_code = redis_store.get("imageCodeId" + image_code_id) # 如果取出图片验证码内容, 删除redis中的缓存 if real_image_code: real_image_code = real_image_code.decode() redis_store.delete("imageCodeId" + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.NODATA, errmsg="验证码已过期") # 校验 if real_image_code.upper() != image_code.upper(): return jsonify(errno=RET.DATAERR, errmsg="验证码错误") # 生成短信验证码 sms_code = "%06d" % random.randint(0, 999999) # 5.发送短信验证码 result = CCP().send_template_sms( mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRES // 60], 2) if result != 0: return jsonify(errno=RET.THIRDERR, errmsg="验证码发送失败") # 6.将短信验证码内容存到redis中 redis_store.set("SMS_" + mobile, sms_code, constants.SMS_CODE_REDIS_EXPIRES) # 记录验证码 current_app.logger.info("SMS_%s,---短信验证码%s" % (mobile, sms_code)) # 7.返回响应 return jsonify(errno=RET.OK, errmsg="验证码已发送,请注意查收")
def sms_code(): """发送短信 1.接受参数(手机号,图片验证码,uuid) 2.校验参数是否齐全,手机号是否合法 3.查询服务器存储的图片验证码 4.跟客户端传入的图片验证码对比 5.如果对比成功,生成短信验证码,并发送短信 6.存储短信验证码到redis,方便注册时比较 7.响应短信验证码发送的结果 """ # 1.接受参数(手机号,图片验证码,uuid) # '{'mobile':'17600992168','image_code':'asdc','image_code_id':'uuid'}' json_dict = request.json mobile = json_dict.get('mobile') image_code_client = json_dict.get('image_code') image_code_id = json_dict.get('image_code_id') # 2.校验参数是否齐全,手机号是否合法 if not all([mobile, image_code_client, image_code_id]): return jsonify(errno=response_code.RET.PARAMERR, errmsg='缺少参数') if not re.match(r'^1[345678][0-9]{9}$', mobile): return jsonify(errno=response_code.RET.PARAMERR, errmsg='手机号格式错误') # 3.查询服务器存储的图片验证码 try: image_code_server = redis_store.get('ImageCode:' + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=response_code.RET.DBERR, errmsg='查询图片验证码失败') if not image_code_server: return jsonify(errno=response_code.RET.NODATA, errmsg='图片验证码不存在') # 4.跟客户端传入的图片验证码对比 if image_code_server.lower() != image_code_client.lower(): return jsonify(errno=response_code.RET.PARAMERR, errmsg='输入验证码有误') # 4.1 校验该手机是否已经注册 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(errno=response_code.RET.DBERR, errmsg="数据库查询错误") if user: # 该手机已被注册 return jsonify(errno=response_code.RET.DATAEXIST, errmsg="该手机已被注册") # 5.如果对比成功,生成短信验证码,并发送短信 sms_code = '%06d' % random.randint(0, 999999) current_app.logger.debug(sms_code) result = CCP().send_template_sms(mobile, [sms_code, 5], 1) if result != 0: return jsonify(errno=response_code.RET.THIRDERR, errmsg='发送短信验证码失败') # 6.存储短信验证码到redis,方便注册时比较 try: redis_store.set('SMS:' + mobile, sms_code, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=response_code.RET.DBERR, errmsg='保存短信验证码失败') # 7.响应短信验证码发送的结果 return jsonify(errno=response_code.RET.OK, errmsg='发送短信验证码成功')
def send_sms_code(): """ 发送短信验证码 0、获取参数(非表单提交,从request.data获取) 1、判断参数是否为空、是否符合规则 2、从redis读取图片内容及编号进行比对 3、图码不符合返回提示信息 4、图码符合--生成短信码内容、发送短信码、提示发送结果 """ # 测试、默认成功 # return jsonify(errno=RET.OK, errmsg="发送成功") # 0、获取参数字典(手机号、图码内容、图码编号-所有参数以json格式传送) # print(request) params_dict = json.loads(request.data) # params_dict = request.json mobile = params_dict.get('mobile') image_code = params_dict.get('image_code') # print('1',image_code) image_code_id = params_dict.get('image_code_id') # 1、校验参数(有值、符合规则) # 是否有值 if not all([mobile, image_code, image_code_id]): # {"xx:xx,yy:yy"} return jsonify(errno=RET.PARAMERR, errmsg="参数不能为空") # 手机号规则校验 if not re.match('^1[35678]\\d{9}$', mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号不合法") # 2、从redis中读取保存的图码内容 try: real_image_code = redis_store.get('imageCodeId' + image_code_id).decode('utf-8') # print('2',real_image_code) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据库查询错误") if not real_image_code: return jsonify(errno=RET.NODATA, errmsg="图片验证码已过期") # 与用户输入参数进行比对(这里为了避免大小写造成的影响,将参数和读取的结果都转换大写再比较) # 3、不符合,提示错误 if real_image_code.upper() != image_code.upper(): return jsonify(errno=RET.DATAERR, errmsg="验证码输入错误") # 4、符合则生成短信码(随机数,确保6位,不足0补) sms_code_str = "%06d" % random.randint(0, 999999) current_app.logger.debug("短信码内容是%s" % sms_code_str) # 发送,过期时间单位为分钟 result = CCP().send_template_sms(mobile, [sms_code_str, constants.SMS_CODE_REDIS_EXPIRES / 60], "1") if result != 0: return jsonify(errno=RET.THIRDERR, errmsg="第三方发送失败") # 保存短信码在redis里 try: redis_store.set("sms" + mobile, sms_code_str, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据库保存失败") # 提示结果(之前需要保存短信码在redis) return jsonify(errno=RET.OK, errmsg="发送成功")
def send_sms_code(): """发送短信验证码""" # 1. 获取参数(手机号,图片验证码,图片验证码id)并进行参数校验 req_dict = request.json if not req_dict: return jsonify(errno=RET.PARAMERR, errmsg='缺少参数') mobile = req_dict.get('mobile') image_code = req_dict.get('image_code') image_code_id = req_dict.get('image_code_id') if not all([mobile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg='参数不完整') if not re.match(r'^1[3578]\d{9}$', mobile): return jsonify(errno=RET.PARAMERR, errmsg='手机号格式不正确') # 2. 根据image_code_id获取对应的图片验证码文本 try: real_image_code = redis_store.get('imagecode:%s' % image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='获取图片验证码失败') if not real_image_code: return jsonify(errno=RET.NODATA, errmsg='图片验证码已过期') # 3. 对应图片验证码 if real_image_code.lower() != image_code.lower(): return jsonify(errno=RET.DATAERR, errmsg='图片验证码错误') # 4. 产生随机6位的短信验证码内容 sms_code = '%06d' % random.randint(0, 999999) current_app.logger.info("短信验证码内容为:%s" % sms_code) # 5. 在redis中保存短信验证码 try: redis_store.set('smscode:%s' % mobile, sms_code, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.looger.error(e) return jsonify(errno=RET.DBERR, errmsg='保存图片验证码失败') # 6. 给用户的手机发送短信验证码 try: res = CCP().send_template_sms( mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRES / 60], 1) except Exception as e: current_app.looger.error(e) return jsonify(errno=RET.THIRDERR, errmsg='发送短信验证码失败') # if res != 0: return jsonify(errno=RET.THIRDERR, errmsg='发送短信验证码失败') # 7. 返回应答,发送短信成功 return jsonify(errno=RET.OK, errmsg='发送短信验证码成功')
def send_sms_code(): """ Realized send sms code :return: """ # Get json to dict with request json method params_dict = request.json print('用户请求的参数: %s' % params_dict) # Get params from front-end mobile = params_dict.get('mobile') image_code = params_dict.get('image_code') image_code_id = params_dict.get('image_code_id') # Judge params integrality if not all([mobile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg="参数不全") # Judge mobile format if not re.match(r'1[356789]\d{9}', mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确") try: # Get image code from redis real_image_code = redis_store.get('imageCodeId_' + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据查询失败") if not real_image_code: return jsonify(errno=RET.NODATA, errmsg="图片验证码已过期") # User input image_code compare to real_image_code if image_code.upper() != real_image_code.upper(): return jsonify(errno=RET.DATAERR, errmsg="图片验证码输入错误") # Generate sms_code sms_code_str = '%06d' % random.randint(0, 999999) current_app.logger.debug("生成的短信验证码是: %s" % sms_code_str) # Send sms_code result = CCP().send_template_sms( mobile, [sms_code_str, constants.SMS_CODE_REDIS_EXPIRES / 300], 1) # Save sms_code to redis if result != 0: return jsonify(errno=RET.THIRDERR, errmsg='发送短信失败') try: redis_store.set('SMS_' + mobile, sms_code_str, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='数据保存失败') # 返回发送结果 return jsonify(errno=RET.OK, errmsg='发送成功')
def sms_code(): # 获取参数 dict_data = request.json mobile = dict_data.get("mobile") image_code = dict_data.get("image_code") image_code_id = dict_data.get("image_code_id") # 校验参数是否为空 if not all([mobile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg="参数不完整") # 校验手机号格式是否正确 if not re.match("1[35789]\d{9}", mobile): return jsonify(errno=RET.DATAERR, errmsg="手机号格式错误") # 通过验证码编号取出,redis中的图片验证码A try: redis_image_code = redis_store.get("image_code:%s" % image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="获取图片验证码异常") # 判断验证码A是否过期 if not redis_image_code: return jsonify(errno=RET.NODATA, errmsg="图片验证码已过期") try: # 未过期,就删除redis中的图片验证码 redis_store.delete("image_code:%s" % image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="图片验证码操作异常") # 判断验证码A和传入进来的验证码B是否相等 if image_code.lower() != redis_image_code.lower(): return jsonify(errno=RET.DATAERR, errnsg="图片验证码填写错误") # 生成验证码 sms_code = "%06d" % random.randint(0, 999999) current_app.logger.debug("短信验证码:%s" % sms_code) # 发送短信验证码,调用ccp ccp = CCP() try: result = ccp.send_template_sms( mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRES / 60], 1) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.THIRDERR, errmsg="云通讯发送异常") if result == -1: return jsonify(errno=RET.DATAERR, errmsg="短信发送失败") # 储存短信验证码到redis中 try: redis_store.set("sms_code:%s" % mobile, sms_code, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="保存验证码失败") # 返回发送状态 return jsonify(errno=RET.OK, errmsg="发送成功")
def send_sms_code(): """ 发送短信的逻辑 1. 获取参数:手机号,图片验证码内容,图片验证码的编号 (随机值) 2. 校验参数(参数是否符合规则,判断是否有值) 3. 先从redis中取出真实的验证码内容 4. 与用户的验证码内容进行对比,如果对比不一致,那么返回验证码输入错误 5. 如果一致,生成验证码的内容(随机数据) 6. 发送短信验证码,并保存验证码,以便校验 7. 告知发送结果 """ # 本质:最后调用loads函数 parameters = flask.request.json # parameters = flask.json.loads(flask.request.data) mobile_phone = parameters.get('mobile') image_code = parameters.get('image_code') image_code_id = parameters.get('image_code_id') if not all([mobile_phone, image_code, image_code_id]): return flask.jsonify(errno=RET.PARAMERR, errmsg='参数有误') if not re.match('1[35678]\\d{9}', mobile_phone): return flask.jsonify(errno=RET.PARAMERR, errmsg='手机号格式不正确') try: real_image_code = redis_db.get('imageCodeId' + image_code_id) except Exception as e: flask.current_app.logger(e) return flask.jsonify(errno=RET.DBERR, errmsg='数据查询失败') else: # 过期 if not real_image_code: return flask.jsonify(errno=RET.NODATA, errmsg='图片验证码过期') if image_code.upper() != real_image_code: return flask.jsonify(error=RET.DATAERR, errmsg='输入验证码错误') # 验证通过,可以发送手机验证码了 sms_code_str = "%06d" % random.randint(0, 999999) # 不去搞和这个编码问题,直接变量 flask.current_app.logger.debug(sms_code_str) # bug:验证码和过期时间以数组形式传给第三方,属于文档阅读不仔细 result = CCP().send_template_sms( mobile_phone, [sms_code_str, constants.SMS_CODE_REDIS_EXPIRES / 5], '1') if result != 0: return flask.jsonify(errno=RET.THIRDERR, errmsg='发送短信失败') else: try: # 手机号作为key redis_db.set(mobile_phone, sms_code_str, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: flask.current_app.logger.error(e) return flask.jsonify(errno=RET.DBERR, errmsg='数据保存失败') return flask.jsonify(errno=RET.OK, errmsg='发送成功')
def sms_code(): # 1.获取参数 req_data = request.data json_data = json.loads(req_data, encoding="utf-8") mobile = json_data["mobile"] image_code = json_data["image_code"] image_code_id = json_data["image_code_id"] # 2.参数的为空校验 if not all([mobile, image_code, image_code_id]): err_rsp(RET.PARAMERR, "参数错误!") # 3.校验手机的格式 if not re.match('1[3-9]\d{9}', mobile): err_rsp(RET.DATAERR, "手机号格式错误!") # 4.通过图片验证码编号获取,图片验证码 try: pic_code = redis_store.get("image_code:%s" % image_code_id) except Exception as e: current_app.logger.error(e) err_rsp(RET.DBERR, "操作redis失败") # 5.判断图片验证码是否过期 if not pic_code: err_rsp(RET.NODATA, "验证码过期") # 6.判断图片验证码是否正确 if pic_code.upper() != image_code.upper(): err_rsp(RET.DATAERR, "图片验证码不正确") # 7.核验成功,删除redis中的图片验证码,短信验证码的层级更高,就不需要图片验证码对用户注册进行验证 try: redis_store.delete("image_code:%s" % image_code_id) except Exception as e: current_app.logger.error(e) err_rsp(RET.DBERR, "操作redis失败") # 8.生成一个随机的短信验证码,调用cCp发送短信,判断是否成功 rd_sms_code = "%06d" % random.randint(0, 999999) ccp = CCP() statue_code = ccp.send_template_sms('18332672733', [rd_sms_code, 5], 1) if statue_code == -1: err_rsp(RET.DBERR, "验证码发送失败") # 9.将短信保存到redis中 try: redis_store.set("rd_sms_code:%s" % mobile, rd_sms_code, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: err_rsp(RET.DBERR, "操作redis失败") # 10.返回 return err_rsp(RET.OK, "短信发送成功!")
def send_sms_code(): """ 发送短信的逻辑 1.获取参数:手机号、图片验证码内容、图片验证码编号 2.校验参数 3.先从redis中取出真实的验证码内容 4.与用户的验证码内容进行对比,如果对比不一致,那么返回验证码输入错误 5.如果一致,生成验证码的内容 6.发送短信验证码 7.告知发送结果 :return: """ # 1.获取参数:手机号、图片验证码内容、图片验证码编号 # params_dict = json.loads(request.data) params_dict = request.json mobile = params_dict.get("mobile") image_code = params_dict.get("image_code") image_code_id = params_dict.get("image_code_id") # 2.校验参数 if not all([mobile, image_code_id, image_code]): return jsonify(errno=RET.PARAMERR, errmsg="参数有误") if not re.match('1[35678]\\d{9}', mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确") # 3.先从redis中取出真实的验证码内容 try: real_image_code = redis_store.get("ImageCodeId" + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据查询失败") if not real_image_code: return jsonify(errno=RET.NODATA, errmsg="图片验证码已过期") # 4.与用户的验证码内容进行对比,如果对比不一致,那么返回验证码输入错误 if real_image_code.upper() != image_code.upper(): print(real_image_code, "---", image_code) return jsonify(errno=RET.DATAERR, errmsg="验证码输入错误") # 5.如果一致,生成验证码的内容 sms_code_str = "%06d" % random.randint(0, 999999) current_app.logger.debug("短信验证码内容是%s" % sms_code_str) # 6.发送短信验证码 result = CCP().send_template_sms(mobile, [sms_code_str, constants.SMS_CODE_REDIS_EXPIRES], 1) # TODO 这里没有真正的发送短信 # if result != 0: # # 代表发送不成功 # return jsonify(RET.THIRDERR, errmsg="发送短信失败") # 保存验证码到redis try: redis_store.set("SMS_" + mobile, sms_code_str, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据保存失败") # 7.告知发送结果 return jsonify(errno=RET.OK, errmsg="发送成功")
def sms_code(): """ 步骤: 1.收集手机号码 验证码image_code 验证码图片中的内容image_code_id 2.校验手机 验证码 验证码过期 3.比对验证码和 redis是否相同 手机号码是否存在(放一下) 4.通过云通讯发送验证码给手机 5.并把验证码保存一下 6.告诉页面发送成功 """ ''' mobile string 是 手机号 image_code string 是 用户输入的图片验证码内容 image_code_id string 是 真实图片验证码编号 ''' # 1.收集手机号码 验证码image_code 验证码图片中的内容image_code_id # 这种方式比较繁琐 request.data.get['mobile'] request.data.get['image_code'] req_dic = request.json # 将获取好的参数接受一下 mobile = req_dic['mobile'] image_code = req_dic['image_code'] image_code_id = req_dic['image_code_id'] # 验证手机 验证 的信息 if not all([mobile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg='缺少参数') # 判断手机号码 if not re.match(r'^1[3-9]\d{9}$', mobile): return jsonify(errno=RET.PARAMERR, errmsg='手机格式不对') # 3比对redis # 获取redis存储的验证码 获取result_image_code_id(格式输出的问题) # decode_responses=True 保证redis获取数据的时候是一个字符串 result_image_code_id = redis_store.get('image_code:%s' % image_code_id) # 判断数据是否过期 if not result_image_code_id: return jsonify(errno=RET.PARAMERR, errmsg='验证码过期重新设置验证码') # 判断验证码是否和redis的相同 # result_image_code_id image_code if result_image_code_id.upper() != image_code.upper(): return jsonify(errno=RET.PARAMERR, errmsg='验证码过期重新设置验证码') # 4 将验证码发送给手机 1 2 0004 0010 sms_rand_id = '%04d' % random.randint(0, 9999) # 将生成好的sms_rand_id 通过运通讯发送出去 # mobile= 手机号码 sms_rand_id 验证码 SMS_CODE_REDIS_EXPIRES 过期时间 1以短信的形式发送过去 res = CCP().send_template_sms(mobile, [sms_rand_id, SMS_CODE_REDIS_EXPIRES], 1) # 判断res的参数 0 成功 -1 失败 if res != 0: return jsonify(errno=RET.PARAMERR, errmsg='手机发送验证码失败') # sms_rand_id存储到数据库中redis mysql redis_store.set('sms_code:%s' % mobile, sms_rand_id, SMS_CODE_REDIS_EXPIRES) # 6将成功的数据发给浏览器 return jsonify(errno=RET.OK, errmsg='发送短信成功')
def send_sms_code(): """发送短信的逻辑""" # TODO 以伪代码默认发送成功 # return jsonify(erron=RET.OK, errmsg="发送成功") '{"mobiel": "18811111111", "image_code": "AAAA", "image_code_id": "u23jksdhjfkjh2jh4jhdsj"}' # 1获取数据 params_dict = request.json # print(params_dict) # TODO 1 mobile = params_dict.get("mobile") image_code = params_dict.get("image_code") image_code_id = params_dict.get("image_code_id") # 2校验数据 if not all([mobile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg="参数有误") if not re.match("1[35678]\\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确") # 3从redis中取出真实验证码内容 try: real_image_code = redis_store.get("ImageCodeId_" + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据查询失败") if not real_image_code: return jsonify(erron=RET.NODATA, errmsg="图片验证码已过期") # 4.与用户的验证码内容进行对比,如果不一致,那么返回验证码输入错误 if real_image_code.upper() != image_code.upper(): return jsonify(errno=RET.DATAERR, errmsg="验证码输入错误") # 5如果一致,生成短信验证码的内容(随机数据) # 随机数字,保证数字长度为6位,不足补0 sms_code_str = "%06d" % random.randint(0, 999999) current_app.logger.debug("短信验证码内容是:%s" % sms_code_str) # 6发送短信验证码 result = CCP().send_template_sms( mobile, [sms_code_str, constants.SMS_CODE_REDIS_EXPIRES / 5], "1") if result != 0: # 代表发送不成功 return jsonify(errno=RET.THIRDERR, errmsg="发送短信失败") # 保存验证码内容到redis try: redis_store.set("SMS_" + mobile, sms_code_str, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据保存失败") # 7发送成功的结果 return jsonify(errno=RET.OK, errmsg="发送短信成功")
def sms_code(): """发送短信""" """ 1.接受参数(手机号,图片验证码,uuid) 2.校验参数是否齐全,手机号是否合法 3.查询服务器存储的图片验证码 4.跟客户端传入的图片验证码对比 5.如果对比成功,生成短信验证码,并发送短信 6.存储短信验证码到redis,方便注册时比较 7.响应短信验证码发送的结果 """ #1.接受参数(手机号,图片验证码,uuid) json_str = request.data.decode() json_dict = json.loads(json_str) mobile = json_dict.get('mobile') image_code_client = json_dict.get('image_code') image_code_id = json_dict.get('image_code_id') #2.校验参数是否齐全,手机号是否合法 if not all([mobile, image_code_client]): return jsonify(errno=response_code.RET.PARAMERR, errmsg='缺少参数') if not re.match(r'^1[345678][0-9]{9}$', mobile): return jsonify(errno=response_code.RET.PARAMERR, errmsg='手机号格式错误') #3.查询服务器存储的图片验证码 try: image_code_server = redis_store.get('imageCodeId:' + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=response_code.RET.DBERR, errmsg='查询图片验证码失败') if not image_code_server: return jsonify(errno=response_code.RET.NODATA, errmsg='图片验证码不存在') #4.跟客户端传入的图片验证码对比 if image_code_server.lower() != image_code_client.lower(): return jsonify(errno=response_code.RET.PARAMERR, errmsg='输入验证码有误') #5.如果对比成功,生成短信验证码,并发送短信 # '%06d' : 如果不够6位,补0.比如:28-->000028 sms_code = '%06d' % random.randint(0, 999999) current_app.logger.debug(sms_code) result = CCP().send_template_sms(mobile, [sms_code, 5], 1) if result != 0: return jsonify(errno=response_code.RET.THIRDERR, errmsg='发送短信验证码失败') #6.存储短信验证码到redis,方便注册时比较 try: redis_store.set('SMS:' + mobile, sms_code, constants.IMAGE_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=response_code.RET.DBERR, errmsg='保存短信验证码失败') #7.响应短信验证码发送的结果 return jsonify(errno=response_code.RET.OK, errmsg='发送短信验证码成功')
def sms_code(): # 获取手机号 # 获取验证码 # 第一次不用存手机号 # 验证码对比失败,应该是验证码的值取的不对,检查获取的验证码是否正确,检查从server中获取的值是否正确 json_dict = request.json mobile = json_dict.get("mobile") image_code_client = json_dict.get("image_code") image_code_id = json_dict.get("image_code_id") print('id1-----------------------', image_code_id) # 从客户端获取的验证码应该和从服务器获取的验证码一致,在前端在获取值的时候,会绑定uuid # 校验参数是否存在 if not all([mobile, image_code, image_code_client]): return jsonify(errno=response_code.RET.PARAMERR, errmsg='缺少参数') # 判断手机格式是否正确 if not re.match(r'^1[345678][0-9]{9}$', mobile): return jsonify(errno=response_code.RET.PARAMERR, errmsg='手机号格式错误') # 校验手机验证码是否和redis中的匹配,在这之前先判断在服务器中是否存在这个验证码?,(不存在的原因是已经失效了)如果不存在就不用往下判断了 try: image_code_id_server = redis_store.get('ImageCode:' + image_code_id) print('id------------------------', image_code_id_server) # 这是空的 except Exception as e: current_app.logger(e) return jsonify(errno=response_code.RET.DBERR, errmsg='查询图片验证码失败') # 如果数据库中获取失败,给客户友好提示 if not image_code_id_server: return jsonify(errno=response_code.RET.DBERR, errmsg='查询图片验证码失败') if image_code_client.lower() != image_code_id_server.lower(): return jsonify(errno=response_code.RET.PARAMERR, errmsg='输入验证码有误') # 如果存在,给手机号发送短信 sms_code = '%06d' % random.randint(0, 99999) result = CCP().send_template_sms(mobile, [sms_code, 5], 1) if result != 0: # if not result: return jsonify(errno=response_code.RET.THIRDERR, errmsg='发送短信验证码失败') # 反之发送成功,成功后将手机号作为建,将手机验证码存储到redis中 try: redis_store.set("SMS" + mobile, sms_code, constants.SMS_CODE_REDIS_EXPIRES) # 将手机号以建的方式存储验证码 except Exception as e: current_app.logger.error(e) return jsonify(errno=response_code.RET.DBERR, errmsg='保存短信验证码失败') # 7.响应短信验证码发送的结果 return jsonify(errno=response_code.RET.OK, errmsg='发送短信验证码成功')
def send_sms_code(): # return jsonify(errno=RET.OK, errmsg="发送成功") # 打开此行,测试手机验证码发送后填写时间倒计时功能是否奏效。 # 1. 获取参数:用户手机号、用户输入的图片验证码、图片验证码的id params_dict = request.json # 等价于 josn.loads(request.data) mobile, image_code, image_code_id = params_dict["mobile"], params_dict["image_code"], params_dict["image_code_id"] # 2. 校验是否有空值,以及可能的手机号格式错误 if not all ([mobile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg="参数有误") if not re.match("^1[35678][0-9]{9}$", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确") # 3. 从redis中取出真实验证码内容 try: real_image_code = redis_store.get("ImageCodeId_" + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据查询失败") if not real_image_code: return jsonify(errno=RET.NODATA, errmsg="图片验证码已过期") # 4. 与用户所输入的验证码对比,如果不一致,返回验证码输入错误 if real_image_code.upper() != image_code.upper(): return jsonify(errno=RET.DATAERR, errmsg="验证码输入错误") # 5. 生成短信验证码内容,随机6位数字符串 sms_code_str = "%06d" % random.randint(0, 999999) # print(sms_code_str) # 确保容联云代码无误后,开发时用这三行,可跳过容联云仅能给指定手机发短信的限制,测试注册成功后自动跳转 # redis_store.set('SMS_' + mobile, sms_code_str, constants.SMS_CODE_REDIS_EXPIRES) # return jsonify(errno=RET.OK, errmsg="发送成功") # 6. 发送短信验证码 result = CCP().send_template_sms(mobile, [sms_code_str, constants.SMS_CODE_REDIS_EXPIRES//60], 1) if result != 0: return jsonify(errno=RET.THIRDERR, errmsg="发送短信失败") # 7. 保存验证码内容到redis try: redis_store.set('SMS_' + mobile, sms_code_str, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据保存失败") # 8. 告知结果 return jsonify(errno=RET.OK, errmsg="发送成功")
def send_sms(): # params_dict=json.loads(request.data) params_dict=request.json mobile = params_dict.get("mobile") image_code = params_dict.get("image_code") image_code_id = params_dict.get("image_code_id") if not all([mobile, image_code_id, image_code]): # 参数不全 return jsonify(errno=RET.PARAMERR, errmsg="参数不全") if not re.match("^1[3578][0-9]{9}$", mobile): # 提示手机号不正确 return jsonify(errno=RET.PARAMERR, errmsg="手机号不正确") try: real_image_code = redis_store.get("ImageCode_" + image_code_id) except Exception as e: current_app.logger.error(e) # 获取图片验证码失败 return jsonify(errno=RET.DBERR, errmsg="获取图片验证码失败") if not real_image_code: # 验证码已过期 return jsonify(errno=RET.NODATA, errmsg="验证码已过期") if image_code.lower() != real_image_code.lower(): # 验证码输入错误 return jsonify(errno=RET.DATAERR, errmsg="验证码输入错误") sms_code_str="%06d" % random.randint(0,999999) current_app.logger.debug("短信验证码内容是:%s" % sms_code_str) result = CCP().send_template_sms(mobile, [sms_code_str, constants.SMS_CODE_REDIS_EXPIRES / 60], "1") if result !=0: # 发送短信失败 return jsonify(errno=RET.THIRDERR, errmsg="发送短信失败") try: redis_store.set("SMS_" + mobile, sms_code_str, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) # 保存短信验证码失败 return jsonify(errno=RET.DBERR, errmsg="保存短信验证码失败") # 7. 返回发送成功的响应 return jsonify(errno=RET.OK, errmsg="发送成功")
def send_sms_code(): # 1.获取参数:手机号, 图片验证码内容, 图片验证码的编号 # params_dict = json.loads(request.data) params_dict = request.json mobile = params_dict.get("mobile") image_code = params_dict.get("image_code") image_code_id = params_dict.get("image_code_id") # 2.校验参数 # 判断参数是否有值 if not all([mobile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg="参数有误") if not re.match('1[35678]\\d{9}]', mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确") # 3.先从redis中取出真实的验证码内容 try: real_image_code = redis_store.get("ImageCodeId" + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据查询失败") if not real_image_code: return jsonify(errno=RET.NODATA, errmsg="图片验证码已过期") # 4. 与用户的验证码内容对比, 如果对比不一致, 那么返回验证码输入错误 if real_image_code.upper() != image_code.upper(): return jsonify(errno=RET.DATAERR, errmsg="验证码输入错误") # 5. 如果一致, 生成短信验证码的内容(随机数据) # 随机数字, 保证数字的长度为6位, 不够在前面补上0 sms_code_str = "%06d" % random.randint(0, 999999) current_app.logger.debug("短信验证码内容是: %s" % sms_code_str) # 6. 发送短信验证码 result = CCP().send_template_sms( mobile, [sms_code_str, constants.SMS_CODE_REDIS_EXPIRES]) if result != 0: # 代表发送不成功 return jsonify(errno=RET.THIRDERR, errmsg="发送短信失败") # 保存验证码内容到redis try: redis_store.set("SMS" + mobile, sms_code_str, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据保存失败") # 7. 告知发送结果 return jsonify(errno=RET.OK, errmsg="发送成功")
def sms_code(): """发送短信""" # 1.接受参数 json_str = request.data json_dict = json.loads(json_str) mobile = json_dict.get('mobile') image_code_client = json_dict.get('image_code') image_code_id = json_dict.get('image_code_id') # 2.校验参数 if not all([mobile, image_code, image_code_id]): return jsonify(errno=response_code.RET.PARAMERR, errmsg='缺少参数') if not re.match(r'^1[345678][0-9]{9}$', mobile): return jsonify(errno=response_code.RET.PARAMERR, errmsg='手机号码不正确') # 3.查询服务器存储的图片验证码 try: image_code_server = redis_store.get('ImageCode:' + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=response_code.RET.DBERR, errmsg='查询图片验证码失败') if not image_code_id: return jsonify(errno=response_code.RET.NODATA, errmsg='图片验证码不存在') print(image_code_server, image_code_client) # 4.跟客户端传入的图片验证码对比 if image_code_server.lower() != image_code_client.lower(): return jsonify(errno=response_code.RET.PARAMERR, errmsg='输入验证码有误') # 5.如果对比成功,生成短信验证码,并发送短信 sms_code = '%06d' % random.randint(0, 999999) current_app.logger.debug(sms_code) result = CCP().send_template_sms(mobile, [sms_code, 5], 1) if result != 0: return jsonify(errno=response_code.RET.THIRDERR, errmsg='发送短信验证码失败') # 6.存储短信验证码到redis,方便比较时注册 try: redis_store.set('SMS:' + mobile, sms_code, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=response_code.RET.DBERR, errmsg='保存短信验证码失败') # 7.响应短信验证码发送的结果 return jsonify(errno=response_code.RET.OK, errmsg='发送短信验证码成功')
def get_sms_code(): """ 短信验证功能 在点击获取验证码时 通过main.js的sendSMSmsg方法中的ajax请求 """ msg_dict = request.json mobile = msg_dict.get('mobile') image_code = msg_dict.get('image_code') image_code_id = msg_dict.get('image_code_id') try: session_img_code = redis_store.get('image_code: %s' % image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR]) if session_img_code: if image_code.lower() == session_img_code.lower(): redis_store.delete(image_code_id) ccp = CCP() msg_info = '%06d' % random.randint(0, 999999) print(msg_info) try: result = ccp.send_template_sms( mobile, [msg_info, SMS_CODE_REDIS_EXPIRES / 60], 1) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.THIRDERR, erromsg=error_map[RET.THIRDERR]) if result == -1: return jsonify(errno=RET.DATAERR, errmsg='短信发送失败') else: try: redis_store.set('sms_code: %s' % mobile, msg_info, SMS_CODE_REDIS_EXPIRES) return jsonify(errno=RET.OK, errmsg=error_map[RET.OK]) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg=error_map[RET.DATAERR]) else: return jsonify(errno=RET.DATAERR, errmsg='验证码输入错误') else: return jsonify(errno=RET.DATAEXIST, errmsg='验证码已失效')
def sms_code(): """短信验证码后端实现""" # 1.取值(图片验证码编号,图片验证码内容,手机号) print('1111') params = request.json mobile = params.get('mobile') image_code_id = params.get('image_code_id') image_code = params.get('image_code') print(params) # 2.判断是否为空 if not all([mobile, image_code_id, image_code]): return jsonify(errno=RET.DATAERR, errmsg='缺少参数') # 3.校验手机号 if not re.match(r'1[35678][0-9]{9}', mobile): return jsonify(error=RET.DATAERR, errmsg='手机号不正确') # 4.用图片验证码编号从redis中取出之前的内容,并与现在取出的验证码内容比较 try: real_image_code = redis_store.get('imageCodeId_' + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='数据库查询错误') if image_code.upper() != real_image_code.upper(): print(image_code) print(real_image_code) return jsonify(errno=RET.DATAERR, errmsg='验证码错误') # 5.生成短信验证码 messcode = "%06d" % random.randint(0, 999999) # 6.将手机号和短信验证码给第三方平台,让其发送 result = CCP().send_template_sms( mobile, [messcode, constants.SMS_CODE_REDIS_EXPIRES / 60], '1') print(result) if result != 0: return jsonify(errno=RET.DATAERR, errmsg='发送失败') # 7.将手机号与短信验证码存入redis中 try: redis_store.set("mobile_" + mobile, messcode) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg='数据保存失败') # 8.发送成功 return jsonify(errno=RET.OK, errmsg='发送成功')
def send_code(): """验证短信""" # 1.获取前端发过来的json数据 mobile = request.json.get('mobile') # 图片验证码内容 image_code = request.json.get('image_code') # 图片验证码uuid image_code_id = request.json.get('image_code_id') print("%s %s %s" % (mobile, image_code, image_code_id)) # 2.校验前端传过来的参数是否有值 if not all([mobile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg='请输入齐全的参数') # 3.校验手机号码 if not re.match(r"^1[34578]\d{9}$", mobile): return jsonify(errno=RET.PARAMERR, errmsg='手机号码不正确') # 4.获取redis数据库存储的验证码 real_image_code = redis_store.get('image_code_' + image_code_id) # 5.判断验证码是否过期 if not real_image_code: return jsonify(errno=RET.NODATA, errmsg="图片验证码已过期") # 6.判断验证码是否正确,转换小写(可忽略大小写) if image_code.lower() != real_image_code.lower(): return jsonify(errno=RET.DATAERR, errmsg="请输入正确的验证码") # 7.生成随机验证码 result = random.randint(0, 9999) sms_code = "%06d" % result print("短信验证码:" + sms_code) # 8.通过云通讯工具发送短信 statusCode = CCP().send_template_sms( mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRES], 1) if statusCode != 0: return jsonify(errno=RET.THIRDERR, errmsg="发送短信失败") # 9.将短信验证码存储到redis数据库 try: redis_store.set('SMS_code' + mobile, sms_code, constants.IMAGE_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="短信验证码存储失败") return jsonify(errno=RET.OK, errmsg="发送短信成功")
def send_sms_code(): mobile=request.json.get('mobile') image_code=request.json.get('image_code') image_code_id=request.json.get('image_code_id') if not all([mobile,image_code,image_code_id]): return jsonify(errno=RET.PARAMERR,errmsg='参数错误') if not re.match(r'1[3456789]\d{9}$',mobile): return jsonify(errno=RET.PARAMERR,errmsg='手机号格式错误') try: real_image_code=redis_store.get('ImageCode_'+image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR,errmsg='获取数据失败') if not real_image_code: return jsonify(errno=RET.NODATA,errmsg='数据已过期') try: redis_store.delete('ImageCode_'+image_code_id) except Exception as e: current_app.logger.error(e) if real_image_code.lower() != image_code.lower(): return jsonify(errno=RET.DATAERR,errmsg='图片验证码错误') sms_code='%06d' % random.randint(0,999999) try: redis_store.setex('SMSCode_'+mobile,constants.SMS_CODE_REDIS_EXPIRES,sms_code) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR,errmsg='保存短信验证码失败') try: ccp=CCP() result=ccp.send_template_sms(mobile,[sms_code,constants.SMS_CODE_REDIS_EXPIRES/60],1) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.THIRDERR,errmsg='发送短信异常') if result==0: return jsonify(errno=RET.OK,errmsg='发送成功') else: return jsonify(errno=RET.THIRDERR,errmsg='发送失败')
def get_sms_code(): """ 生成短信验证码 :return: """ params_dict = request.json mobile = params_dict["mobile"] image_code = params_dict["image_code"] image_code_id = params_dict["image_code_id"] if not all([mobile, image_code_id, image_code]): return jsonify(errno=RET.PARAMERR, errmsg="参数错误") if not re.match(r"1[3456789]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, errmsg="手机号码输入格式不正确") try: real_image_code = redis_store.get("imageCodeId" + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据查询错误") if not real_image_code: return jsonify(errno=RET.PARAMERR, errmsg="验证码过期") if image_code.upper() != real_image_code.upper(): return jsonify(errno=RET.PARAMERR, errmsg="验证码输入不正确") sms_code_id = "%06d" % random.randint(0, 999999) print(sms_code_id) result = CCP().send_template_sms( mobile, [sms_code_id, constants.SMS_CODE_REDIS_EXPIRES], 1) if result: return jsonify(errno=RET.DATAERR, errmsg="短信验证码发送失败") if not result: try: redis_store.set("SMS" + mobile, sms_code_id, constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(RET.DBERR, errmsg="数据存储错误") return jsonify(errno=RET.OK, errmsg="验证成功")
def get_sms_code(): """ 思路分析: 1.获取参数 2.校验参数,为空检验,格式校验 3.取出redis中的图片验证码 4.判断是否过期 5.删除redis中图片验证码 6.正确性判断 7.生成短信验证码 8.发送短信 9.判断是否发送成功 10.保存短信验证码到redis 11.返回响应 """ # 1.获取参数 json_data = request.data dict_data = json.loads(json_data) mobile = dict_data.get('mobile') image_code = dict_data.get('image_code') image_code_id = dict_data.get('image_code_id') # 2.校验参数,为空检验,格式校验 if not all([mobile,image_code,image_code_id]): return jsonify(errno=RET.PARAMERR,errmsg="参数不全") if not re.match('1[35789]\d{9}',mobile): return jsonify(errno=RET.DATAERR,errmsg="手机号格式不正确") # 3.取出redis中的图片验证码 try: redis_image_code = redis_store.get('image_code:%s'%image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR,errmsg="数据获取失败") # 4.判断是否过期 if not redis_image_code: return jsonify(errno=RET.NODATA,errmsg="图片验证码过期") # 5.删除redis中图片验证码 try: redis_store.delete('image_code:%s'%image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR,errmsg="获取失败") # 6.正确性判断 if image_code.upper() != redis_image_code.upper(): return jsonify(errno=RET.DATAERR,errmsg="图片验证码错误") # # 7.生成短信验证码 sms_code = '%06d'%random.randint(0,999999) current_app.logger.debug('短信验证码 = %s'%sms_code ) # 8.发送短信 try: ccp = CCP() result = ccp.send_template_sms(mobile,[sms_code,constants.SMS_CODE_REDIS_EXPIRES/60],1) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.THIRDERR,errmsg="云通讯发送失败") # 9.判断是否发送成功 if result == -1: return jsonify(errno=RET.DATAERR,errmsg="发送短信失败") # 10.保存短信验证码到redis try: redis_store.set('sms_code:%s'%mobile,sms_code,constants.SMS_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR,errmsg="短信保存失败") # 11.返回响应 return jsonify(errno=RET.OK,errmsg="发送成功")
def sms_code(): # 获取参数 mobile = request.json.get('mobile') image_code = request.json.get('image_code') image_code_id = request.json.get('image_code_id') # 检查参数 if not all([image_code, mobile]): return jsonify(errno=RET.PARAMERR, errmsg='参数缺失') if not re.match(r'1[3456789]\d{9}$', mobile): return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误') try: text = redis_store.get('Imagecode_' + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='验证码已过期') try: redis_store.delete('Imagecode_' + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='获取数据失败') # 判断获取结果 if not text: return jsonify(errno=RET.NODATA, errmsg='图片验证码已过期') # 判断图片验证码输入是否正确而 if image_code.lower() != text.lower(): return jsonify(errno=RET.PARAMERR, errmsg='图片验证码错误') # 删除图片验证码 try: redis_store.delete('Imagecode_' + image_code_id) except Exception as e: current_app.logger.error(e) # 判断手机是否注册 try: user = User.query.filter(User.mobile == mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='数据异常') if user: return jsonify(errno=RET.DATAEXIST, errmsg='手机号已注册') # 调用第三方工具发送短信 sms_data = "%06d" % random.randint(1, 999999) print(sms_data) # 存储验证码信息 try: redis_store.setex('smscode_' + mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_data) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='数据异常') # 调用云通讯发送短信 try: ccp = CCP() result = ccp.send_template_sms( mobile, [sms_data, constants.SMS_CODE_REDIS_EXPIRES / 60], 1) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.THIRDERR, errmsg='短信发送异常') if result == 0: return jsonify(errno=RET.OK, errmsg='短信验证码已发送') else: return jsonify(errno=RET.THIRDERR, errmsg='短信发送失败')