def get_image_code():
"""实现验证码图片显示"""
# 1.接受把前段uuid并当做img_code_id
img_code_id = request.args.get('code_id')
# 2.生成验证码内容value(图片和真实数据)
name, text, image = captcha.generate_captcha()
current_app.logger.debug('图片验证码:%s' % text)
# 3.将uuid和真实数据保存到redis,并添加超时时间
redis_store.set(img_code_id, text, IMAGE_CODE_REDIS_EXPIRES)
# 4.设置respons数据的类型
# 5.创建response对象
response = make_response(image)
response.headers["Content-Type"] = "image/jpg"
# 6.将生成的图片返回给前段展示
return response
def image_code():
image_code_id = request.args.get("imageCodeId", None)
if not image_code_id:
abort(404)
name, text, image = captcha.generate_captcha()
try:
redis_store.set("ImageCodeId:" + image_code_id,
text,
ex=constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
abort(500)
response = make_response(image)
response.headers['Content-Type'] = 'image/jpg'
return response
def send_sms():
"""验证验证码正确，发送短信"""
# 1. 接收参数，mobile，image_code, image_code_id
data = request.json
mobile = data.get("mobile", None)
image_code = data.get("image_code", None)
image_code_id = data.get("image_code_id", None)
# 2. 判断参数不能为空, 判断参数
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="手机号格式不正确")
# 3. 验证redis数据库中验证码是否正确
try:
real_image_code = redis_store.get("image_code_id_" + image_code_id)
except Exception as ret:
current_app.logger.error(ret)
return jsonify(errno=RET.DBERR, errmsg="数据查询错误")
if not real_image_code:
return jsonify(errno=RET.NODATA, errmsg="图片验证码过期")
# 4. 通过验证后，生成并存储短信验证码，并通过第三方网站向手机号发送验证码
if image_code.upper() != real_image_code.upper():
return jsonify(errno=RET.DATAERR, errmsg="验证码输入错误")
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 get_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('1[3456789]\\d{9}', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式不正确')
# 通过验证码id取出验证码
try:
image = redis_store.get('image_code:%s' % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='获取图片验证码失败')
# 判断验证码是否过期
if not image:
return jsonify(errno=RET.NODATA, errmsg='图片验证码过期')
# 判断输入的验证码是否正确
if image_code.upper() != image.upper():
return jsonify(errno=RET.DATAERR, errmsg='图片验证码不正确')
# 生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
# 保存验证码在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='保存短信验证码失败')
# 打印短信验证码代替云通讯
print(sms_code)
# 调用云通讯发送短信
# 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)
# redis_store.delete('sms_code:%s' % mobile)
# return jsonify(errno=RET.THIRDERR, errmsg='调用云通讯失败')
# if result != 0:
# redis_store.delete('sms_code:%s' % mobile)
# return jsonify(errno=RET.DATAERR, errmsg='发送短信失败')
return jsonify(errno=RET.OK, errmsg='发送短信成功')
def modify_password():
"""修改密码"""
if request.method == "GET":
return render_template('news/user_modify_password.html')
else:
# 接收参数
user_phone = request.form.get('phone')
password = request.form.get('password')
# 校验参数
if not all([user_phone, password]):
return jsonify(errno=response_code.RET.PARAMERR, errmsg='参数错误')
if not re.match('^1[35678][0-9]{9}$', user_phone):
return jsonify(errno=response_code.RET.PARAMERR, errmsg='手机号错误')
try:
# 如果手机号正常，通过手机号查询用户
modify_user = User.query.filter(User.mobile == user_phone).first()
except Exception as e:
logging.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg='查询用户失败')
if not modify_user:
return jsonify(errno=response_code.RET.NODATA, errmsg='您没有注册')
# 发送短信验证码
# 随机生成6位短信验证码
sms_code = '%06d' % random.randint(0, 999999)
print('短信验证码:', sms_code)
# 发送短信
# result = CCP().send_template_sms(modify_user, [sms_code, 3], 1)
# # 判断发送的结果
# if result != 0:
# logging.error(result)
# return jsonify(errno=response_code.RET.PARAMERR, errmsg='短信发送失败!')
# # 保存短信码到redis便于下次验证
try:
redis_store.set('SMSCode:' + user_phone, sms_code,
constants.SMS_CODE_REDIS_EXPIRES)
except Exception as e:
logging.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg='短信码保存失败!')
# 修改数据
modify_user.password = password
# 同步数据
try:
db.session.commit()
except Exception as e:
logging.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg='保存新密码失败')
# 返回响应结果
return jsonify(errno=response_code.RET.OK, errmsg='修改成功')
def image_code():
imageCodeId = request.args.get('imageCodeId')
if not imageCodeId:
abort(403)
name, text, image = captcha.generate_captcha()
current_app.logger.debug(text)
try:
redis_store.set('imageCoedId:' + imageCodeId, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logging.error(e)
abort(500)
response = make_response(image)
response.headers['Content-Type'] = 'image/jpg'
return response
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 get_imgecode():
"""获取验证码图片"""
# 1.获取参数
# a.获取前端传上来的uuid编码，imageCodeId
imageCodeId = request.args.get("imageCodeId", "")
# 2.校验参数
# a.判断uuid编码是否为空
if not imageCodeId:
abort(404)
# 3.逻辑处理
# a.获取生成验证码图片对象,获取真实的验证码
# ('fXZJN4AFxHGoU5mIlcsdOypa', 'JGW9', '\x89PNG\r\n\x1a\n\x00\x00\x00\r...')
name, text, image = captcha.generate_captcha()
# b.将图片验证码真实的之使用编码存储到redis
try:
# eg:imagecode_uuid:dadw
redis_store.set("imagecode_%s" % imageCodeId,
text,
ex=constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
abort(500)
# 4.返回值处理
# a.将图片对象返回给前端展示
# 创建响应对象
response = make_response(image)
# 设置响应对象中响应头内容的类型
response.headers["Content-Type"] = "image/jpeg"
# 返回响应对象
return response
def send_sms_code():
"""
发送短信验证码视图
1.获取参数：手机号，图片验证码，图片验证码的编号
2.校验参数：参数是否符合规则，判断是否有值
3.校验图片验证码内容，校验不成功，返回验证码错误
4.生成手机验证码，发送短信验证码
5.告知发送结果
:return: json
"""
# 1.获取前端的参数，包括用户输入手机号，图片验证码和生成的图片验证码编号，数据以json的格式发送
params_dic = request.json
mobile = params_dic.get("mobile")
image_code = params_dic.get("image_code")
image_code_id = params_dic.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.通过验证，生成短信验证码内容（随机数），将内容存入redis
sms_code_str = "%06d" % random.randint(0, 999999)
current_app.logger.debug("短信验证码内容：{}".format(sms_code_str))
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="验证码生成保存失败")
# 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.告知发送结果
return jsonify(errno=RET.OK, errmsg="发送成功")
def registration():
'''代理日常加粉统计'''
# 校验token
token = request.headers.get('Authorization')
data = verify_token(token)
if data == False:
return jsonify(errno=RET.DATAERR, errmsg='校验token失败')
if request.method == 'POST':
agent_id = request.get_json().get('agent_id')
today_fans = request.get_json().get('today_fans')
if not redis_store.get('agent_current_fans_' + str(agent_id)):
# 判断redis中是否存有今日当前的粉丝量
agents = AgentInfo.query.filter_by(id=agent_id, is_delete=0)
for agent in agents:
today = datetime.now()
expire_time = datetime(today.year, today.month, today.day, 23,
59, 59) # 有效期至当天的23：59：59
stat = Stat()
stat.agent_id = agent_id
stat.today_fans = int(today_fans)
redis_store.set('agent_current_fans_' + str(agent_id),
agent.current_fans)
redis_store.expireat('agent_current_fans_' + str(agent_id),
expire_time)
agent.current_fans = agent.current_fans + int(today_fans)
stat.total_fans = agent.current_fans
db.session.add(agent)
db.session.add(stat)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
return jsonify(errno=RET.SERVERERR, errmsg='提交失败')
agent_info = [AgentInfo.to_dict(agent) for agent in agents]
return jsonify(errno=RET.OK, agent_info=agent_info, errmsg='ok')
else:
# 如果redis存在今日当前的粉丝量，则不允许提交
return jsonify(errno=RET.DATAERR, errmsg='你已提交')
else:
try:
agents = AgentInfo.query.filter(AgentInfo.status == 1).filter(
AgentInfo.is_delete == 0)
agent_info = [AgentInfo.to_dict(agent) for agent in agents]
return jsonify(errno=RET.OK, agent_info=agent_info, errmsg='ok')
except Exception as e:
return jsonify(errno=RET.SERVERERR, errmsg='数据库查询错误')
def get_sms_code():
"""
1.取到参数mobile，image_code，image_code_id
2.判断是否有值
3.取出redis里面存放的图片验证码
4.与用户提交的验证码内容进行对比，如果对比不一致，返回 输入错误的验证码
5.如果一致，生成验证码的内容（随机数据）
6.发送短信验证码，并保存到redis中，设置过期时间
7.告知发送结果
:return:
"""
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, image_code_id]):
return jsonify(errno=RET.DBERR, errmsg="参数有误")
if not re.match("1[3456789]\d{9}", mobile):
return jsonify(errno=RET.DBERR, 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.NODATA, errmsg="图片验证码已过期")
if real_image_code.upper() != image_code.upper():
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,int(constants.SMS_CODE_REDIS_EXPIRES / 60)],1)
# # 发送不成功
# if result!=0:
# return jsonify(errno=RET.THIRDERR, errmsg="发送短信失败")
# 发送成功 1.存储到redis以便后续验证 2.发送成功消息
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 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():
# 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_code():
"""
发送短信,获取图片验证码编号，手机号码，图片验证码内容
:return:
"""
#获取用户输入的手机号，图片验证码，图片编号
# return jsonify(errno=RET.OK, errmsg="发送短信成功")
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,image_code_id]):
return jsonify(errno=RET.PARAMERR,errmsg="参数有误")
#效验手机号码是否正确
if not re.match('1[35678]\\d{9}',mobile):
return jsonify(errno=RET.PARAMERR,errmsg="手机号码是否正确")
#从redis取出手机号
try:
real_image_code=redis_store.get("ImageCodeId_%s"% image_code_id)
current_app.logger.debug("ImageCodeId_"+ image_code_id)
current_app.logger.debug(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="图片验证码已过期")
#对比验证码
if real_image_code.upper() != image_code.upper():
return jsonify(errno=RET.DATAERR, errmsg="验证码输入错误")
#生成短信验证码,保证数字为6位，不够用0补上
sms_code_str="%06d"%random.randint(0,999999)
current_app.logger.debug(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.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 send_sms_code():
"""
发送短信的逻辑
:return:
"""
# 1.将前端参数转为字典
mobile = request.json.get('mobile') # 手机号
# print(mobile)
image_code = request.json.get('image_code') # 用户输入的图片验证码内容
image_code_id = request.json.get('image_code_id') # 真实图片验证码编号
# 2. 校验参数(参数是否符合规则，判断是否有值)
if not all([mobile, image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 判断参数是否有值
# match尝试从字符串的起始位置匹配，返回值是数组或者是null
# 验证手机号的正则
if not re.match(r'^1[3456789]\d{9}$', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误')
# 3. 先从redis中取出真实的图片验证码内容
try:
real_image_code = redis_store.get('image_code' + 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.DBERR, errmsg='图形有效期已过')
# 4. 与用户的验证码内容进行对比，如果对比不一致，那么返回验证码输入错误
if real_image_code != image_code:
return jsonify(errno=RET.DATAERR, errmsg='图形验证码输入错误')
# 5. 如果一致，生成短信验证码的内容(随机数据)
sms_code_num = '%06d' % random.randint(0, 999999)
print(sms_code_num)
# 6. 发送短信验证码，云通讯辅助
CCP().send_template_sms(
mobile, [sms_code_num, constants.SMS_CODE_REDIS_EXPIRES / 5], "1")
# if not result != 0:
# return jsonify(errno=RET.THIRDERR, errmsg='短信验证发送失败')
# # 保存验证码内容到redis
try:
redis_store.set('sms_code_num' + mobile, sms_code_num,
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_sms_code():
# 1.获取参数：手机号、uuid、图片验证码
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')
print(dict_data)
# 2.校验参数是否为空
if not all([mobile, image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 3.验证手机号格式
if not re.match('1[356789]\\d{9}', mobile):
return jsonify(errno=RET.DATAERR, errmsg='手机号格式错误')
# 4.取出uuid在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='查找图片验证码失败')
# 5.判断图片验证码是否过期
if not redis_image_code:
return jsonify(errno=RET.NODATA, errmsg='图片验证码过期')
# 6.判断验证码是否一致
if image_code.lower() != redis_image_code.lower():
return jsonify(errno=RET.DATAERR, errmsg='图片验证码不正确')
# 7.生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
# 8.通过云通讯发送短信验证码（手机号，（短信验证码、有效期），模板）
# ccp = CCP()
# result = ccp.send_template_sms(mobile,[sms_code,5],1)
# if result == -1:
# return jsonify(errno=RET.THIRDERR,errmsg='短信验证码发送失败')
current_app.logger.debug('短信验证码是：%s' % sms_code)
# 9.保存到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.DATAERR, errmsg='短信保存失败')
# 10.返回前端
return jsonify(errno=RET.OK, errmsg='发送成功')
def sms_code():
# 获取前端传递过来的json数据
mobile = request.json.get("mobile")
# 参数表示图片验证码的内容
image_code = request.json.get("image_code")
# 表示图片验证码的id
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="请输入正确的手机号码")
# 获取到redis中的图片验证码
real_image_code = redis_store.get("image_code" + image_code_id)
# 判断redis中的验证码是否过期
if not real_image_code:
return jsonify(errno=RET.NODATA, errmsg="当前验证码已过期")
# 到了这里说明验证码还在有效期,判断用户输入的验证码是否和redis中保存的相同,都转换为小写,方便用户体验
if image_code.lower() != real_image_code.lower():
return jsonify(errno=RET.PARAMERR, errmsg="请输入正确的验证码")
# 通过随机数生成一个6位的验证码,并用0占位补齐六位
random_sms_code = "%06d" % random.randint(0, 999999)
# 将产生的随机数短信内容储存在redis中,方便注册的时候进行验证
# 第一个参数表示key, 第二个参数表示六位随机数字, 第三个参数表示数据有效期,单位是秒
redis_store.set("sms_code_" + mobile, random_sms_code, constants.SMS_CODE_REDIS_EXPIRES)
print("短信内容 = " + random_sms_code)
# 发送短信到指定的手机号码>>括号中数据1>手机号码2>随机数字,5分钟有效,返回状态码为1
statuCode = CCP().send_template_sms(mobile, [random_sms_code, 5], 1)
print(statuCode)
if statuCode != 0:
return jsonify(errno=RET.THIRDERR, errmsg="短信发送失败")
return jsonify(errno=RET.OK, errmsg="发送短信成功")
def get_image_code():
"""获取图片验证码"""
# 1.获取图片验证码的uuid
code_id = request.args.get('code_id')
print("uuid= " + code_id)
# 2.生成验证码
name, text, image = captcha.generate_captcha()
print("验证码= " + text)
# 3.验证码ｕuid当作key存储到redis(key,value,有效时间）
redis_store.set('image_code_' + code_id, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
# 4.返回验证码图片给浏览器
resp = make_response(image)
# 设置响应的格式为image/jpg
resp.headers['content_type'] = 'image/jpg'
return resp
def image_code():
url = request.url
# 获取到uuid,uuid是一个唯一值
code_id = request.args.get('code_id')
print("UUID = " + code_id)
# 生成图片验证码
# 第一个参数:表示图片验证码的名字
# 第二个参数:表示图片验证码的内容
# 第三个参数:表示图片验证码的图片
name, text, image = captcha.generate_captcha()
print("图片验证码的内容:" + text)
# 设置redis
redis_store.set('image_code_' + code_id,text,constants.IMAGE_CODE_REDIS_EXPIRES)
# 返回一张图片,目前返回的是空图片
resp = make_response(image)
resp.headers['Content-Type'] = 'image/jpg'
return resp
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():
print("请求sms_code 的url:" + request.url)
# mobile = request.json.get("mobile")
# image_code = request.json.get("image_code")
# image_code_id = request.json.get("image_code_id")
# print(image_code_id)
# redis_image_code = redis_store.get("sms_code" +image_code_id)
# print(redis_image_code)
# print(image_code)
# if not redis_image_code:
# return jsonify(errno = RET.NODATA,errmsg = "图片验证码过期")
# # 随机生成验证码
# result = random.randint(0, 999999)
# # 保持验证码是6位
# sms_code = "%06d" % result
# print("短信验证码 = " + sms_code)
# # 发送短信
# # 第一个参数发送给哪个手机号,最多一次只能发送200个手机号,通过,分割
# # 第二个参数是数组形式进行发送[sms_code,100],数组里面的第一个参数表示机验证码, 第二个参数表示多久过期, 单位是分钟
# # 第三个参数表示模板id 默认值表示1
# # statusCode = CCP().send_template_sms(mobile,[sms_code, 5],1)
# #
# # if statusCode != 0:
# # return jsonify(errno = RET.THIRDERR,errmsg = "发送短信失败")
# return jsonify(errno=RET.OK, errmsg="发送短信成功")
mobile = request.json.get("mobile")
image_code = request.json.get("image_code")
image_code_id = request.json.get("image_code_id")
print(mobile, image_code, image_code_id)
redis_image_code_id = redis_store.get("sms_code" + image_code_id)
print(redis_image_code_id)
if not redis_image_code_id:
return jsonify(errno=RET.NODATA, errmsg="验证码过期")
if image_code.lower() != redis_image_code_id.lower():
return jsonify(errno=RET.PARAMERR, errmsg="验证码输入错误")
result = random.randint(0, 999999)
sms_code = "%06d" % result
redis_store.set("sms_code" + mobile, sms_code)
print("短信验证码：" + sms_code)
return jsonify(errno=RET.OK, errmsg="发送短信成功")
def sms_code():
"""短信验证视图"""
# 接受参数
jsno_str = request.data
# jsno_str转成字典
json_dict = json.loads(jsno_str)
mobile = json_dict['mobile']
image_code = json_dict['image_code']
image_code_id = json_dict['image_code_id']
# 校验验证码是否齐全 手机号码格式是否正确
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='手机号格式错误')
try:
image_code_server = redis_store.get('imageCode:' + image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errnp=response_code.RET.DBERR, errmsg='查询图片验证码失败')
if not image_code_server:
return jsonify(errnp=response_code.RET.NODATA, errmsg='图片验证码不存在')
# 跟客户端传入的图片验证码做对比
if image_code_server.lower() != image_code.lower():
return jsonify(errnp=response_code.RET.PARAMERR, errmsg="输入的验证码有误")
# 生成短信验证码 不够六位补零
sms_code = '%06d' % random.randint(0, 999999)
print("手机验证码:" + sms_code)
# 调用CCP()发送短信方法
# result = CCP().send_template_sms(mobile, [sms_code, 5], 1)
# if result != 0:
# 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, ermsg="储存短信验证码失败")
return jsonify(errno=response_code.RET.OK, errmsg="发送短信验证码成功")
def sms_code():
# 获取到用户在页面上输入的手机号码
mobile = request.json.get("mobile")
# 获取到用户在页面上输入的验证码
image_code = request.json.get("image_code")
# 获取到验证码的id
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("1[345678]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="请输入正确的手机号")
# 从redis当中获取到图片验证码
redis_image_code = redis_store.get("sms_code_" + image_code_id)
# 判断验证码是否过期
if not redis_image_code:
return jsonify(errno=RET.NODATA, errmsg="验证码已过期")
# 在匹配验证码的时候,需要全部转换成大写或者小写,这样是为了提高用户体验
if redis_image_code.lower() != image_code.lower():
return jsonify(errno=RET.PARAMERR, errrmsg="请输入正确的验证码")
# 发送短信
# 生成6位数字的验证码
result = random.randint(0, 999999)
# 保证每次获取到的验证码肯定是6位
sms_code = "%06d" % result
print("短信验证码 = " + sms_code)
# 存储短信验证码到redis当中
# 第一个参数表示redis的key
# 第二个参数表示redis的值
#第三个参数表示过期时间,单位是秒
redis_store.set("code_" + mobile, sms_code, 300)
# 发送短信验证码
# 第一个参数表示你想发送给哪个手机号
# 第二个参数是一个数组[sms_code,10],数组里面的第一个参数表示随机验证码,第二个参数表示过期时间,单位是分钟
# statusCode = CCP().send_template_sms(mobile,[sms_code,10],1)
#
# if statusCode != 0:
# return jsonify(errno = RET.THIRDERR,errmsg = "发送短信失败")
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_image_code():
# 1.request args of id
image_code_id = request.args.get('code_id')
# 2.create image code content
name, text, image_data = captcha.generate_captcha()
# 3.save in redis
try:
redis_store.set('image_code_id_' + image_code_id, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return make_response(jsonify(error=RET.DATAERR, errmsg='保存验证码失败'))
resp = make_response(image_data)
resp.headers['Content-Type'] = 'image/jpg'
# 4.return image
return image_data
def get_image_code():
code_id = request.args.get('code_id', None)
if not code_id:
abort(403)
name, text, image = captcha.generate_captcha()
print(name, text, image)
current_app.logger.debug("图片验证码内容是：%s" % text)
try:
redis_store.set("ImageCodeId_" + code_id, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
abort(500)
response = make_response(image)
# 设置数据的类型，以便浏览器更加智能识别其是什么类型
response.headers["Content-Type"] = "image/jpg"
return response
def get_image_code():
# 获取参数
cur_id = request.args.get('cur_id')
pre_id = request.args.get('pre_id')
# 生成图片验证码
name, text, image_code = captcha.generate_captcha()
# 保存到数据库
try:
redis_store.set('image_code:%s' % cur_id, text, constants.IMAGE_CODE_REDIS_EXPIRES)
if pre_id:
redis_store.delete('image_code:%s' % pre_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='保存验证码失败')
resp = make_response(image_code)
resp.headers['Content-Type'] = 'image/jpg'
return resp
def imageCode():
print(request.url)
code_id = request.args.get("code_id")
print(code_id)
if not code_id:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# re1,图片验证码的名字 re2, 图片验证码的内容 re3 验证码的图片
name, text, image = captcha.generate_captcha()
print("图片验证码的内容---" + text)
# 存数据到redis para1 key, 唯一，刚好使用图片生产的ｕｕｉｄ, 第二个是value, 第三个是过期时间
redis_store.set("sms_code_" + code_id, text,
constants.SMS_CODE_REDIS_EXPIRES)
# 初始化一个响应体
resp = make_response(image)
return resp
def get_image_code():
"""获取图片验证码"""
# 1. 获取前端生成图片验证码id
code_id = request.args.get("code_id")
# 2. 调用工具生成图片验证码
name, text, image = captcha.generate_captcha()
# 3. 保存图片内容到redis数据库
try:
redis_store.set("imageCodeId_" + code_id, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return make_response(jsonify(errno=RET.DBERR, errmsg="保存图片验证码失败"))
# 4.返回数据
response = make_response(image)
response.headers['Content-Type'] = 'image/jpg'
return response
def get_image_code():
# 1.获取到当前的图片编号id
code_id = request.args.get('code_id')
# 2.生成验证码
name, text, image = captcha.generate_captcha()
print(text)
try:
redis_store.set('ImageCode_' + code_id, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return make_response(jsonify(errno=RET.DATAERR, errmsg='保存图片验证失败'))
# 返回响应内容
resp = make_response(image)
# 设置内容类型
resp.headers['Content-Type'] = 'image/jpg'
return resp
