def register():
# 1.获取参数
# json_data = request.data
# dict_data = json_data.loads(json_data)
# 上面两句话可以写成一句话
# request.get_json()
# request.json,等价于上面一句话
dict_data = request.json
mobile = dict_data.get("mobile")
sms_code = dict_data.get("sms_code")
password = dict_data.get("password")
# 2.校验参数,为空校验
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 3.手机号格式校验
if not re.match("1[35789]\d{9}", mobile):
return jsonify(errno=RET.DATAERR, errmsg="手机号格式不正确")
# 4.根据手机号,去redis中取出短信验证码
try:
redis_sms_code = redis_store.get("sms_code:%s" % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取短信验证码异常")
# 5.判断短信验证码是否过期
if not redis_sms_code:
return jsonify(errno=RET.NODATA, errmsg="短信验证码已过期")
# 6.删除redis的短信验证码
try:
redis_store.delete("sms_code:%s" % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="删除短信验证码异常")
# 7.判断传入的短信验证码和redis中取出的是否一致
if sms_code != redis_sms_code:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误")
# 8.创建用户对象,设置属性
user = User()
user.nick_name = mobile
user.mobile = mobile
# user.password_hash = jiami(password) user.mobile = mobile
# user.password_hash = password(password) user.mobile = mobile
user.password = password
# 9.保存用户到数据库mysql
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="用户注册失败")
# 10.返回响应
return jsonify(errno=RET.OK, errmsg="注册成功")
def send_sms_codes():
# 获取参数
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.PARAMERR, errmsg='参数有误')
if not re.match(r'1[3-9]\d{9}', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式不正确')
try:
real_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='数据库查询错误')
if not real_image_code:
return jsonify(errno=RET.PARAMERR, errmsg='图片验证码已过期')
if image_code.upper() != real_image_code.upper():
return jsonify(errno=RET.DATAERR, errmsg='图片验证码不正确')
# 业务逻辑
sms_code = "%06d" % random.randint(0, 999999)
current_app.logger.debug("短信验证码为: %s" % sms_code)
try:
redis_store.set("sms_code_%s" % mobile, sms_code, 3600)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库查询失败')
# result = CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRES], "1")
return jsonify(errno=RET.OK, errmsg='发送成功')
def name():
redis_store.set('name', 'laowang')
print(redis_store.get('name'))
# session['name']='zhangsan'
# print(session.get('name'))
return render_template('news/index.html')
def sms_code():
mobile = request.json.get("mobile")
image_request = request.json.get("image_code")
image_code_id = request.json.get("image_code_id")
print(image_request)
image_redis = redis_store.get(image_code_id)
print(image_redis.decode())
if image_redis is None:
return jsonify(errno=RET.NODATA, errmsg='图形验证码过期')
if image_request != image_redis.decode():
return jsonify(errno=RET.DATAERR, errmsg="图片验证错误")
if not re.match(r"^1[35678]\d{9}$", mobile):
return jsonify(errno=RET.NODATA, errmsg='手机号格式错误')
mobile_count = User.query.filter_by(mobile=mobile).count()
if mobile_count > 0:
return jsonify(errno=RET.DATAEXIST, errmsg='手机号已经被使用')
smscode = str(random.randint(100000, 999999))
print(smscode)
# 云平台发送手机密码
sendTemplateSMS(mobile, [smscode, 5], 1)
print(smscode)
# 把验证码存在redis中 用手机好作为id
redis_store.setex(mobile, constants.SMS_CODE_REDIS_EXPIRES, smscode)
return jsonify(errno=RET.OK, errmsg="")
def register():
"""
注册
:return:
"""
# 1、获取参数
param_dict = request.json
mobile = param_dict.get("mobile", "")
smscode = param_dict.get("smscode", "")
password = param_dict.get("password", "")
# 2、检验
# 参数是否齐全
if not all([mobile, smscode, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 短信验证码是否正确
try:
# 获取短信验证码
real_sms_code = redis_store.get("SMS_" + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取本地短信验证码失败！")
if not real_sms_code:
# 短息验证码过期
return jsonify(errno=RET.NODATA, errmsg="短信验证码失效")
# 校验
real_sms_code = real_sms_code.decode()
if smscode != real_sms_code:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误")
# 删除短息验证码
try:
redis_store.delete("SMS_" + mobile)
except Exception as e:
current_app.logger.error(e)
# 3、保存数据
user = User()
user.mobile = mobile
user.nick_name = mobile
# 在User模型中对密码加密处理
# hash_password = generate_password_hash(password)
user.password = password
db.session.add(user)
try:
db.session.commit()
except Exception as e:
db.session.rollback() # 回滚
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="保存数据失败")
# 保持用户登录状态
session["user_id"] = user.id
# session["nick_name"] = user.nick_name
# session["mobile"] = user.mobile
# 4、返回响应
return jsonify(errno=RET.OK, errmsg="OK")
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([mobile, image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg="请输入参数")
if not re.match("1[356789]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="请输入手机号码")
real_image_code = redis_store.get("image_code_" + image_code_id)
if not real_image_code:
return jsonify(errno=RET.NODATA, errmsg="图片验证码已过期")
if real_image_code.lower() != image_code.lower():
return jsonify(errno=RET.PARAMERR, errmsg="请输入正确的验证码")
result = random.randint(0, 999999)
sms_code = "%06d" % result
print("短信验证码 = " + sms_code)
redis_store.set("sms_code_" + mobile, sms_code,
constants.SMS_CODE_REDIS_EXPIRES)
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="发送短信成功")
def register():
# 1.获取前端传过来的参数： mobile smscode password
mobile = request.json.get('mobile')
sms_code = request.json.get('smscode')
password = request.json.get('password')
# 2.获取redis中保存的短信验证码，判断是否过期
real_sms_code = redis_store.get('sms_code_' + mobile)
if not real_sms_code:
return jsonify(errno=RET.NODATA, errmsg='短信验证码已过期')
# 3.判断输入的和redis中的短信验证码是否一致
print('短信码是否一致： ', sms_code, real_sms_code)
if sms_code != real_sms_code:
return jsonify(errno=RET.PARAMERR, errmsg='请输入正确的短信验证码')
# 4.创建一个用户， 来保存注册信息,持久化到数据库
user = User()
user.mobile = mobile
user.password = password
user.nick_name = mobile # 昵称
user.last_login = datetime.now() # 获取当前时间
db.session.add(user)
db.session.commit()
print('持久化成功')
# 5.返回注册成功
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("^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:
print("图片过期判断")
return jsonify(errno=RET.NODATA, errmsg="图片验证已经过期")
# 说明redis没有过期,判断用户输入的验证码,转换成小写再进行判断
if image_code.lower() != real_image_code.lower():
return jsonify(errno=RET.PARAMERR, errmsg="请输入正确的图片验证码")
# 通过随机数生成一个六位数的验证码 如过不够六位,通过零补齐
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)
# statuCode = CCP().send_template_sms(mobile, [random_sms_code, 5], 1)
# if statuCode != 0:
# return jsonify(errno=RET.THIRDERR, errmsg="短信发送失败")
return jsonify(errno=RET.OK, errmsg="发送短信成功")
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 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 sms_code():
'''发送短信验证码'''
# 1,接收参数(手机号,图片验证码,图片uuid)
# 2,校验参数(是否存在,手机好是否合理)
# 3,查询服务器存储的图片验证码
# 4,和客户端传入的图片验证码进行比较
# 5,如果成功,生成短信验证码
# 6,调用CCP()封装的发送短信的方法,发送短信给手机
# 7,存储短信验证码到服务器, 后来注册时判断输入的验证码是否正确
# 8,响应发送短信验证码的结果
# 1,接收参数(手机号,图片验证码,图片uuid) ajax发来的
# 传过来的是字符串,里面是字典
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_client,image_code_id]):
# 响应给ajax的状态(errno表示状态码, errmsg表示状态说明) PARAMERR:代表参数错误
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='图片验证码不存在')
print(image_code_server, image_code_client)
# 4,和客户端传入的图片验证码进行比较 (服务器查出来的是大写,转成小写比较)
if image_code_server.lower() != image_code_client:
return jsonify(errno=response_code.RET.DATAERR, errmsg='输入验证码有误')
# 5,如果成功,生成短信验证码(不足六位数字,前面用0补充)
sms_codes = '%06d' % random.randint(0, 999999)
print(sms_code)
# 6,调用CCP()封装的发送短信的方法,发送短信给手机
# result = CCP().send_template_sms(mobile,[sms_code,5],1) # 5; 5分钟后过期, 1: 表示1号默认短信模板
# if result != 0:
# return jsonify(errno=response_code.RET.THIRDERR, errmsg='发送短信验证码失败') # 第三方错误
# 7,存储短信验证码到服务器, 后来注册时判断输入的验证码是否正确
try:
redis_store.set('SMS:' + mobile, sms_codes, constants.IMAGE_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 register():
"""
1. 获取参数和判断是否有值
2. 从redis中获取指定手机号对应的短信验证码的
3. 校验验证码
4. 初始化 user 模型，并设置数据并添加到数据库
5. 保存当前用户的状态
6. 返回注册的结果
"""
# 获取用户输入的手机号
mobile = request.json.get("mobile")
# 获取用户输入的短信验证码
smscode = request.json.get("smscode")
# 获取用户输入的密码
password = request.json.get("password")
# 获取到redis服务器里面存储的短信验证码
real_sms_code = redis_store.get("sms_code_"+mobile)
# 判断redis服务器里存储的短信验证码是否过期
if not real_sms_code:
return jsonify(errno=RET.NODATA,errmsg="验证码已过期")
# 判断用户输入的短信验证码和redis服务器里面的短信验证码是否一致
if smscode != real_sms_code:
return jsonify(errno=RET.PARAMERR,errmsg='请输入正确的验证码')
# 创建一个用户对象用来注册用户
user = User()
user.mobile = mobile
user.password = password
user.nick_name = mobile #昵称
#获取当前的时间,用来注册
user.last_login = datetime.now()
# 往数据库进行持久化操作
db.session.add(user)
db.session.commit()
return jsonify(errno=RET.OK,errmsg="注册成功")
def send_sms_code():
data = request.json
mobile=data.get('mobile')
image_code =data.get('image_code')
image_code_id = data.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[3-9][0-9]{9}',mobile):
return jsonify(errno = RET.PARAMERR,errmsg ='手机格式不正确')
count =User.query.filter(User.mobile == mobile).count()
if count > 0:
return jsonify(errno=RET.DATAEXIST,errmsg='手机号已经注册')
try:
redis_code =redis_store.get('img_'+image_code_id)
if redis_code:
redis_code =redis_code.decode()
redis_store.delete('img_'+image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR,errmsg = 'redis数据有问题')
if not redis_code:
return jsonify(errno=RET.DATAERR,errmsg = '图片验证码以及过期')
if image_code.lower() != redis_code.lower():
return jsonify(errno=RET.DATAERR,errmsg = '验证码不一致')
from random import randint
sms_code = '%06d'%randint(0,999999)
result = CCP().send_template_sms(mobile,[sms_code,constants.SMS_CODE_REDIS_EXPIRES/60],1)
# if result !=0:
#return jsonify(errno=RET.DATAERR,errmsg = '发送失败')
try:
redis_store.setex('sms_'+mobile,constants.SMS_CODE_REDIS_EXPIRES,sms_code)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR,errmsg = '发送失败')
return jsonify(errno=RET.OK,errmsg = 'OK')
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_id,image_code_id]):
return jsonify(errno = RET.PARAMERR,errmsg = '请输入参数')
# if not re.match(r'1[^269]\d{9}$',mobile):
# return jsonify(errno = RET.PARAMERR,errmsg = '请输入正确的电话号码')
# 3. 先从redis中取出真实的验证码内容
redis_image_code = redis_store.get('image_code_' + image_code_id)
# 4. 与用户的验证码内容进行对比，如果对比不一致，那么返回验证码输入错误
if not redis_image_code:
return jsonify(errno = RET.NODATA,errmsg = '图片验证码已过期')
if redis_image_code.lower() != image_code.lower():
return jsonify(errno = RET.PARAMERR,errmsg = '请输入正确的图片验证码')
# 5. 如果一致，生成短信验证码的内容(随机数据)
random_sms = '%06d' % random.randint(0,999999)
# status_code = CCP().send_template_sms(mobile, [random_sms, 2], 1)
# if status_code != 0:
# return jsonify(errno=RET.THIRDERR, errmsg='第三方系统错误')
# 6. 发送短信验证码,保存验证码内容到redis
redis_store.set('random_sms_' + mobile,random_sms,SMS_CODE_REDIS_EXPIRES)
# 7. 告知发送结果
print('手机验证码为：%s' % random_sms)
# 8. 返回注册结果
return jsonify(errno = RET.OK,errmsg = '发送短信成功')
def register():
mobile = request.json.get('mobile')
sms_code = request.json.get('sms_code')
password = request.json.get('password')
print(mobile, sms_code, password)
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg='请输入正确参数')
sms_code_redis_store = redis_store.get('sms_code_' + mobile)
if not sms_code_redis_store:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码已经过期')
if sms_code_redis_store != sms_code:
return jsonify(errno=RET.DATAERR, errmsg='请输入正确的短信校验码')
try:
redis_store.delete('sms_code_' + mobile)
except Exception as e:
current_app.logger.error(e)
user = User()
user.mobile = mobile
user.nick_name = mobile
user.password = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 注册便登陆
session['user_id'] = user.id
session['nick_name'] = user.nick_name
session['mobile'] = user.mobile
user.last_login = datetime.now()
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([mobile,image_code,image_code_id]):
return jsonify(errno = RET.PARAMERR,errmsg = "请输入正确的信息")
# 验证手机号是否填写正确
if not re.match(r"1[356789]\d{9}",mobile):
return jsonify(errno = RET.PARAMERR,errmsg = "请输入正确的手机号")
# 获取数据库中的验证码
real_image_code = redis_store.get("image_code_" + image_code_id)
if not real_image_code:
return jsonify(errno = RET.DATAERR,errmsg = "验证码已过期")
# 获取数据库中的验证码与填写的验证码是否一致
if real_image_code.lower() != image_code.lower():
return jsonify(errno = RET.PARAMERR,errmsg = "请输入正确的验证码")
result = random.randint(0,999999)
sms_code = "%06d"%result
print(sms_code)
redis_store.set("sms_code"+mobile,sms_code,constants.SMS_CODE_REDIS_EXPIRES)
# 发送短信
# 第一个参数表示手机号
# 第二个参数表示[],左边的参数表示短信验证码，右边的参数表示多少分钟之后过期
# 第三个参数表示模板id,固定的写法是１
# 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 = "发送成功")
def register():
mobile = request.json.get("mobile")
# 用户输入的手机验证码
smscode = request.json.get("smscode")
password = request.json.get("password")
# if not re.match("1[345678]\d{9}",mobile):
# return jsonify(errno = RET.PARAMERR,errmsg = "手机号码输入错误")
# 校验手机验证码
# 从redis里面获取数据里面缓存的手机验证码
redis_sms_code = redis_store.get("code_" + mobile)
if redis_sms_code != smscode:
return jsonify(errno=RET.PARAMERR, errmsg="验证码输入错误")
user = User()
user.mobile = mobile
user.nick_name = mobile
user.password = password
# datetime.now() 获取到当前的时间,存储到数据库
user.last_login = datetime.now()
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
# 把用户注册的数据设置给session
session["mobile"] = user.mobile
session["user_id"] = user.id
session["nick_name"] = user.mobile
return jsonify(errno=RET.OK, errmsg="注册成功")
def register():
mobile = request.json.get("mobile")
smscode = request.json.get("smscode")
password = request.json.get("password")
if not all([mobile,smscode,password]):
return jsonify(errno = RET.PARAMERR,errmsg = "请输入内容")
sms_code = redis_store.get("sms_code" + mobile)
print(sms_code)
if not sms_code:
return jsonify(errno = RET.DATAERR,errmsg = "验证码已过期")
if sms_code != smscode:
return jsonify(errno = RET.PARAMERR,errmsg = "验证码输入错误")
user = User()
user.nick_name = mobile
user.password = password
user.mobile = mobile
user.last_login = datetime.now()
db.session.add(user)
db.session.commit()
return jsonify(errno = RET.OK,errmsg = "注册成功")
def register():
# 用户输入的手机号
mobile = request.json.get("mobile")
# 用户输入的短信验证码
smscode = request.json.get("smscode")
# 用户输入的密码
password = request.json.get("password")
# 获取redis服务器里面存储的短信验证码
real_sms_code = redis_store.get("sms_code_" + mobile)
if not real_sms_code:
return jsonify(errno=RET.NODATA, errmsg="短信验证码已失效")
# 判断用户输入的短信验证码是否和服务器里面存储的一致
if smscode != real_sms_code:
return jsonify(errno=RET.PARAMERR, errmsg="请输入正确的短信验证码")
# 创建一个用户对象用来注册用户
user = User()
user.mobile = mobile
user.password = password
user.nick_name = mobile
# 获取当前时间,用来记录注册时间
user.last_login = datetime.now()
# 网数据库进行持久化操作
db.session.add(user)
db.session.commit()
return jsonify(errno=RET.OK, errmsg="注册成功")
def register():
mobile = request.json.get('mobile')
smscode = request.json.get('smscode')
password = request.json.get('password')
if not all([mobile,smscode,password]):
return jsonify(errno = RET.PARAMERR,errmsg = '请输入正确的参数')
# 注册
# 获取到redis数据库里面的短信验证码
real_sms_code = redis_store.get('sms_code_' + mobile)
if not real_sms_code:
return jsonify(errno = RET.NODATA,errmsg = '短信验证码已经过期')
if smscode != real_sms_code:
return jsonify(errno = RET.PARAMERR,errmsg = '请输入正确的短信验证码')
user = User()
user.nick_name = mobile
user.password = password
user.mobile = mobile
# 提交注册用户到数据库里面
db.session.add(user)
db.session.commit()
return jsonify(errno = RET.OK,errmsg = '注册成功')
def register():
'''注册：向用户表中添加一条数据'''
# 1.接收
mobile = request.json.get('mobile')
sms_request = request.json.get('smscode')
password = request.json.get('password')
# 2.验证
# 2.1非空
if not all([mobile, sms_request, password]):
return jsonify(errno=RET.NODATA, errmsg='数据不完整')
# 2.2获取短信验证码
sms_redis = redis_store.get(mobile)
if sms_redis is None:
return jsonify(errno=RET.NODATA, errmsg='短信验证码过期')
# 2.3手机验证码是否正确
if sms_request != sms_redis.decode():
return jsonify(errno=RET.DATAERR, errmsg='验证码错误')
# 3.处理:向表中添加数据
user = User()
user.nick_name = mobile
user.mobile = mobile
user.password = password
# user.pasword(pwd)
db.session.add(user)
db.session.commit()
# 4.响应
return jsonify(errno=RET.OK, errmsg='')
def register():
"""
注册逻辑：
１．获取参数
２．校验参数
３．
:return:
"""
param_dict=json.loads(request.data)
# param_dict=request.json
mobile=param_dict.get('mobile')
smscode=param_dict.get('smscode')
password=param_dict.get('password')
if not all([mobile,smscode,password]):
return jsonify(errn=RET.PARAMERR,errmsg='参数错误')
if not re.match(r'1[3578]\d{9}',mobile):
return jsonify(errno=RET.DATAERR,errmsg='手机号错误')
try:
real_smscode=redis_store.get('mobilbe'+mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR,errmsg='数据库查询错误')
if not real_smscode:
return jsonify(errno=RET.NODATA,errmsg='短信验证码不存在或失效')
if smscode!=real_smscode:
return jsonify(errno=RET.DATAERR,errmsg='短信验证码输入错误')
# 验证通过后，将用户数据保存到数据库中
user=User()
user.mobile=mobile
# 昵称初始化为手机号
user.nick_name=mobile
# 记录最后一次登录信息
user.last_login=datetime.now()
# 密码要加密保存
# 在模型定义中进行密码加密的实现
# 使用@property装饰器和@password.setter装饰器实现对密码的加密
user.password=password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR,errmsg='保存数据异常')
# 注册成功后，转为登录状态，将用户信息保存在session中
session['user_id']=user.id
session['mobile']=user.mobile
session['nick_name']=user.nick_name
# 返回注册成功状态
return jsonify(errno=RET.OK,errmsg='数据保存成功')
def register():
mobile = request.json.get("mobile")
password = request.json.get("password")
smscode = request.json.get("smscode")
print(smscode, "ddddddddddddddd")
if not all([mobile, password, smscode]):
return jsonify(erron=RET.NODATA, errmsg="信息不全")
# 获得手机验证码
smscode_redis = redis_store.get(mobile)
print(smscode_redis.decode())
if smscode_redis is None:
return jsonify(erron=RET.NODATA, errmsg="没有手机验证吗过期")
if smscode != smscode_redis.decode():
return jsonify(erron=RET.DATAERR, errmsg="手机验证码部正确")
user = User()
user.mobile = mobile
user.nick_name = mobile
user.password = password
db.session.add(user)
db.session.commit()
return jsonify(erron=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_scatter():
if request.method == "GET":
return render_template("scatter.html")
recv_data = request.get_data()
keywords = recv_data.decode()
data = redis_store.get("keywords_" + keywords)
if data is not None:
data = json.loads(data)
return jsonify({
"code": 200,
"msg": data,
})
s = Scatter(keywords, "us")
data = s.create_scatter_data()
print(data)
if data is None:
return jsonify({
"code": 400,
"msg": "页面抓取失败",
})
try:
redis_store.set("keywords_" + keywords, json.dumps(data), 1800)
except Exception as e:
current_app.logger.error(e)
return jsonify({
"code": 200,
"msg": data,
})
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([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.DATAERR, errmsg="手机号不正确")
real_image_code = redis_store.get("image_code_" + image_code_id)
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="请输入正确的验证码")
# 编辑发送的短信内容
result = random.randint(0, 999999)
sms_code_random = "%06d" % result
# 存储短信验证码
redis_store.set("sms_code_" + mobile, sms_code_random,
constants.SMS_CODE_REDIS_EXPIRES)
print("短信内容是：" + sms_code_random)
statusCode = CCP().send_template_sms(mobile, [sms_code_random, 5], 1)
if statusCode != 0:
return jsonify(errno=RET.THIRDERR, errmsg="短信发送失败")
return jsonify(errno=RET.OK, errmsg="成功")
def retrieve_password():
'''忘记密码并重置密码'''
mobile = request.get_json().get('mobile')
sms_code = request.get_json().get('sms_code')
new_password = request.get_json().get('new_password')
# 调取redis查询手机验证码
try:
rel_sms_code = redis_store.get('smscode:%s' % mobile)
except Exception as e:
print(e)
return jsonify(errno=RET.DBERR, errmsg='数据库查询出错')
if not rel_sms_code:
return jsonify(errno=RET.NODATA, errmsg='短信验证码已过期')
if rel_sms_code == sms_code:
return jsonify(errno=RET.OK, errmsg='短信验证码校验成功')
try:
user = User.query.filter_by(phone_number=mobile).first()
if user:
user.password = new_password
db.session.add(user)
try:
db.session.commit()
except:
db.session.rollback()
return jsonify(errno=RET.SERVERERR, errmsg='提交失败')
else:
return jsonify(errno=RET.USERERR, errmsg='用户不存在')
except:
return jsonify(errno=RET.SERVERERR, errmsg='数据库查询错误')
return jsonify(errno=RET.OK, errmsg='修改成功')
def sms_code():
user = None
mobile = request.json.get('mobile')
real_image_code = request.json.get('image_code')
id_image_code = request.json.get('image_code_id')
if not all([mobile, real_image_code, id_image_code]):
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# print('验证手机好')
if not re.match('1[3456789]\d{9}', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='请输入正确手机号')
user = User.query.filter(User.mobile == mobile).first()
print(user)
# if not user is None:
# return jsonify(error=RET.DATAEXIST, errmsg='此用户已注册,请直接登陆')
image_code = redis_store.get('image_code_' + id_image_code)
if not image_code:
return jsonify(errno=RET.NODATA, errmsg='图片验证码过期')
if real_image_code.lower() != image_code.lower():
return jsonify(errno=RET.PARAMERR, errmsg='请输入正确的验证码.')
redis_store.delete('image_code_' + id_image_code)
random_sms_code = '%06d' % random.randint(0, 999999)
redis_store.set('sms_code_' + mobile, random_sms_code, 300)
print(mobile, real_image_code, id_image_code, random_sms_code)
# 发送短信
# statuCode = CCP().send_template_sms(mobile, [random_sms_code, 5], 1)
# if statuCode != 0:
# return jsonify(errno = RET.THIRDERR,errmsg = "短信发送失败")
return jsonify(errno=RET.OK, errmsg='发送成功.')
def register():
params_dict = json.loads(request.data)
mobile = params_dict.get('mobile')
smscode = params_dict.get('sms_code')
password = params_dict.get('password')
# 验证参数
if not all([mobile, smscode, password]):
return jsonify(errno=RET.PARAMERR, errmsg='参数有误')
# 验证手机号是否正确
if not re.match('1[35678]\\d{9}', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号码格式不正确')
# 从redis出取出验证码
try:
real_sms_code = redis_store.get('SMS_' + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据查询失败')
# 表示验证码过期,一定要记住从redis取出后进行decode，否则怎么死的都不知道
if not real_sms_code:
return jsonify(errno=RET.NODATA, errmsg='手机验证码错误或者已过期')
else:
real_sms_code = real_sms_code.decode()
# 对比验证码
if real_sms_code != smscode:
return jsonify(errno=RET.DATAERR, errmsg='验证码输入错误')
# 进行用户注册
user = User()
user.mobile = mobile
user.nick_name = mobile
# 第一次注册的时候最后一次登录信息就直接伴随着模型的创建写入到了数据库
user.last_login = datetime.now()
# 对密码进行处理,在user的数据模型类中自动加密，将加密解锁设置到user.password_hash
user.password = password
# 添加到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='数据保存失败')
# 往session中保存状态表示当前已登录
"""
这里的session是使用的是Config类中的存储在redis中的session，下面这几个变量值都是存在一个相同的session——id下面的
并不是在redis分开存储了3个，而是在一个session_id下，值为一个字典，字典里面包含这3个变量
"""
session['user_id'] = user.id
session['mobile'] = user.mobile
session['nick_name'] = user.nick_name
# 返回响应
return jsonify(errno=RET.OK, errmsg='注册成功')
def register():
"""注册功能"""
# 1.获取参数和判断参数是否有值
mobile = request.json.get("mobile")
smscode = request.json.get("smscode")
password = request.json.get("password")
# 2.从redis中获取指定手机号码对应的短信验证码
phon_smscode = redis_store.get(mobile)
print(phon_smscode, 123)
# print(smscode, 12)
# 3.校验校验码
if phon_smscode != smscode:
return jsonify(errno=RET.DATAERR, errmsg="验证码错误")
# 4.初始化user模型,设置数据并添加到数据库
user = User()
user.mobile = mobile
user.password = password
user.nick_name = mobile
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存错误")
# 5.保存用户登录状态
session["nick_name"] = mobile
session["mobile"] = mobile
# 6.返回注册结果
print("---------success-------------------")
return jsonify(errno=RET.OK, errmsg="注册成功")
