def register(): mobile = request.json.get('mobile') smscode = request.json.get('sms_code') password = request.json.get('password') if not all([mobile, smscode, password]): return jsonify(errno=RET.PARAMERR, errmsg='参数不全') try: redis_sms_code = redis_store.get('sms_' + mobile) if redis_sms_code.decode() == smscode: redis_store.delete('sms' + mobile) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='redis错误') if not redis_sms_code: return jsonify(errno=RET.NODATA, errmsg='验证码过期') if redis_sms_code.decode() != smscode: return jsonify(errno=RET.DATAERR, errmsg='验证码不一致 ') 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) db.session.rollback() return jsonify(errno=RET.DBERR, errmsg='数据保存失败') session['user_id'] = user.id session['mobile'] = mobile session['nick_name'] = mobile return jsonify(errno=RET.OK, errmsg='注册成功')
def send_sms(): param_dict = request.json mobile = param_dict.get("mobile") image_code = param_dict.get("image_code") image_code_id = param_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.DATAERR, errmsg="手机号不正确") real_image_code = redis_store.get("ImageCode_" + image_code_id) if real_image_code: real_image_code = real_image_code redis_store.delete("ImageCode_" + image_code_id) else: return jsonify(errno=RET.NODATA, errmsg="验证码已过期") if image_code.lower() != real_image_code.lower(): return jsonify(errno=RET.DATAERR, errmsg="验证码输入错误") user = User.query.filter_by(mobile=mobile).first() if user: return jsonify(errno=RET.DATAEXIST, errmsg="该手机已被注册") result = random.randint(0, 999999) sms_code = "%06d" % result current_app.logger.debug("短信验证码的内容:%s" % sms_code) redis_store.set("SMS_" + mobile, sms_code, constants.SMS_CODE_REDIS_EXPIRES) return jsonify(errno=RET.OK, errmsg="发送成功验证码为%s" % sms_code)
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 get_code(): """ 1.获取参数 2.校验参数,cur_id 3.判断是否有上个pre_id,如果有则删除redis中上次图片验证码 4.生成图片验证码,并存储到redis中 5.返回图片验证码 :return: """ # redis_store.set() cur_code_id = request.args.get("cur_id") per_code_id = request.args.get("pre_id") if not cur_code_id: return "图片编码不能为空" try: if per_code_id: redis_store.delete("image_code:%s"%per_code_id) except Exception as e: current_app.logger.error(e) try: image_code_id, text, image_data = captcha.captcha.generate_captcha() redis_store.set("image_code:%s"%cur_code_id,text,constants.IMAGE_CODE_REDIS_EXPIRES) except Exception as e: current_app.logger.error(e) return ("存储图片失败") response = make_response(image_data) response.headers['Content-Type'] = "image/jpg" return response
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') # uuid if not all([mobile, image_code, image_code_id]): return jsonify(errno=RET.PARAMERR, errmsg='参数缺少') if not re.match(r'^1[345678][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='图片验证码已经过期') 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.PARAMERR, errmsg='图片验证码不一致') try: user = User.query.filter(User.mobile == mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='查询数据库异常') else: if user: return jsonify(errno=RET.DATAEXIST, errmsg='手机号码已注册') # 生成随机数 sms_code = '' for i in range(6): sms_code += str(random.randint(0, 9)) print(sms_code) # 生成短信验证码 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 = sms.CCP() # 手机号,【验证码 , 有效时间/分】,模版1 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 0 == result: return jsonify(errno=RET.OK, errmsg='发送成功') else: return jsonify(errno=RET.THIRDERR, errmsg='发送短信失败')
def get_image_code(): """ 获取请求参数 生成图片验证码 保存到redis 返回图片验证码 :return: """"" # 获取用户利用get请求发送的数据cur_id cur_id = request.args.get('cur_id') prcur_id = request.args.get('prcur_id') name, text, image_data = captcha.generate_captcha() # 将图片验证码写入到redis中 try: redis_store.set('image_code:%s'%cur_id, text, constants.IMAGE_CODE_REDIS_EXPIRES) if prcur_id: redis_store.delete('image_code:%s'%prcur_id) except Exception as e: current_app.logger.error(e) response = make_response(image_data) response.headers['Content-Type'] = 'image/jpg' return response
def get_image_code(): # 1,获取参数 # 2.生成验证码 # 3.保存到redis # 5.返回图片验证码 # 1.获取当前验证码图片的编号id code_id = request.args.get('code_id') pre_id = request.args.get('pre_id') # 2.生成验证码 name, text, image_data = captcha.generate_captcha() # 3.保存到redis try: redis_store.set('image_code:%s' % code_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) # 4.返回验证码,设置返回数据格式 response = make_response(image_data) response.headers['Content-Type'] = 'image/jpg' return response
def get_image_code(): """ 1.获取请求参数 2.生成图片验证码 3.保存到redis 4.返回图片验证码 :return: """ # 1.获取请求参数,args是获取?后面的参数 cur_id = request.args.get("cur_id") pre_id = request.args.get("pre_id") # 2.生成图片验证码 name, text, image_data = captcha.generate_captcha() # 3.保存到redis 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) # 4.返回图片验证码 response = make_response(image_data) response.headers['Content-Type'] = 'image/jpg' return response
def get_image_code(): """ 1.获取请求参数 2.生成图片验证码 3.保存到reids 4.返回图片验证码 :return: """ # 1.获取请求参数,args是获取?后面的参数 www.baidu.com?name=zhangsan&age=13 cur_id = request.args.get("cur_id") pre_id = request.args.get("pre_id") # 2.生成图片验证码 name, text, image_data = captcha.generate_captcha() # 3.保存到reids try: # key + value +time redis_store.set("image_code:%s" % cur_id, text, constants.IMAGE_CODE_REDIS_EXPIRES) #判断是否有上一个uuid,如果存在则删除 if pre_id: redis_store.delete("image_code:%s" % pre_id) except Exception as e: current_app.logger.error(e) # 4.返回图片验证码 response = make_response(image_data) response.headers["Content-Type"] = "image/jpg" return response
def getImage(): from info import redis_store image_code_id = request.args.get('image_code_id') pre_image_code_id = request.args.get('pre_image_code_id') try: redis_store.delete('iamge_code_id:' + pre_image_code_id) except Exception as err: current_app.logger.error(err) return jsonify(errno=RET.DBERR, errmsg='数据库操作故障') try: name, code_text, image = captcha.captcha.generate_captcha() except Exception as err: current_app.logger.error(err) return jsonify(errno=RET.SERVERERR, errmsg='生成验证码失败') # 存储图片验证码内容和识别id; try: redis_store.setex('iamge_code_id:' + image_code_id, constants.IMAGE_CODE_REDIS_EXPIRES, code_text) except Exception as err: current_app.logger.error(err) return make_response(jsonify(errno=RET.DBERR, errmsg='验证码保存失败')) # 给浏览器返回验证码图片; ret = make_response(image) ret.headers['content_type'] = 'image/jpg' return ret
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 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 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 sms_code(): 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_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("image_code_" + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.PARAMERR, errmsg="获取验证码失败") if not real_image_code: return jsonify(errno=RET.PARAMERR, errmsg="验证码已过期") if real_image_code.lower() != image_code.lower(): return jsonify(errno=RET.PARAMERR, errmsg="请输入正确的验证码") redis_store.delete("image_code_" + image_code_id) # 删除验证码 generate_sms_code = "%06d" % random.randint(1, 999999) redis_store.set("sms_code_" + mobile, generate_sms_code, constants.SMS_CODE_REDIS_EXPIRES) print("短信验证码:", generate_sms_code) # result = CCP().send_template_sms(mobile, [generate_sms_code, 5], 1) # if result != 0: # return jsonify(errno=RET.PARAMERR, errmsg="第三方错误") print("短信验证码发送成功") return jsonify(errno=RET.OK, errmsg="短信验证码发送成功")
def image_code(): """ 1.获取参数 2.校验参数(为空校验) 3.生成图片验证码 4.保存图片验证码到redis 5.判断是否由上个图片验证码编号,有则删除 6.返回图片验证码即可 :return: """ # 1.获取参数 cur_id = request.args.get("cur_id") pre_id = request.args.get("pre_id") # 2.校验参数(为空校验) if not cur_id: return jsonify(errno=RET.NODATA, errmsg="图片验证码编号不存在") # 3.生成图片验证码 name, text, image_data = captcha.generate_captcha() try: # 4.保存图片验证码到redis constants验证码有效期 redis_store.set("image_code:%s" % cur_id, text, constants.IMAGE_CODE_REDIS_EXPIRES) # 5.判断是否由上个图片验证码编号,有则删除 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="图片验证码异常") # 6.返回图片验证码即可 response = make_response(image_data) response.headers["Content-Type"] = "image/jpg" return response
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(): params_dict = request.json # 1.get mobile number infomation mobile = params_dict.get('mobile') # 2.get image code infomation image_code = params_dict.get('image_code') # 3.get code id infomation image_code_id = params_dict.get('image_code_id') # 4.verify all infomations if not all([mobile, image_code, image_code_id]): return jsonify(error=RET.PARAMERR, errmsg='参数不全') # 5.verify mobile number is true or false if not re.match(r'^1[3-9][0-9]{9}', mobile): return jsonify(error=RET.DATAERR, errmsg='手机号码不正确') # 6.verify image code real_image_code = None try: real_image_code = redis_store.get('image_code_id_' + image_code_id) if real_image_code: # to decode infomations from redis real_image_code = real_image_code.decode() redis_store.delete('image_code_id_' + image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(error=RET.DBERR, errmsg='验证码查询错误') if not real_image_code: return jsonify(error=RET.NODATA, errmsg='验证码已过期') if image_code.lower() != real_image_code.lower(): return jsonify(error=RET.DATAERR, errmsg='验证码输入错误') try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(error=RET.DBERR, errmsg='数据查询错误') if user: return jsonify(error=RET.DATAEXIST, errmsg='用户已存在,不能重复注册') # 7.create sms and send it to the mobile num result = random.randint(0, 999999) current_app.logger.info(result) sms_code = '%06d' % result current_app.logger.debug('sms image code content %s' % sms_code) # result = CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRES / 60], '1') # if result != 0: # return jsonify(error=RET.THIRDERR, errmsg='send sms failed') # 8.save sms to 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(error=RET.DBERR, errmsg='报错短信验证码失败') # 9.reutrn response return jsonify(error=RET.OK, errmsg='ok')
def send_sms(): param_dict = request.json mobile = param_dict.get('mobile') image_code_id = param_dict.get('image_code_id') image_code = param_dict.get('image_code') if not all([mobile, image_code_id, image_code]): return jsonify(errno=RET.PARAMERR, errmsg='参数不足') if not re.match(r'^1[345678][0-9]{9}$', mobile): return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误') # print('params =', param_dict) try: real_image_code = redis_store.get('imageCodeId_%s' % image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='数据库查询失败') if real_image_code: try: redis_store.delete('imageCodeId_%s' % image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='数据库查询失败') else: return jsonify(errno=RET.NODATA, errmsg='验证码已过期') if real_image_code.lower() != image_code.lower(): return jsonify(errno=RET.DATAERR, errmsg='验证码错误') try: user = User.query.filter_by(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_code = random.randint(0, 999999) sms_code = '%06d' % sms_code print('sms_code =', sms_code) try: redis_store.set('SMS_%s' % mobile, sms_code, ex=constants.SMS_CODE_REDIS_EXPIRES) 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) # if result == 0: # try: # redis_store.set('SMS_%s' % mobile, sms_code, ex=constants.SMS_CODE_REDIS_EXPIRES) # except Exception as e: # current_app.logger.error(e) # return jsonify(errno=RET.DBERR, errmsg='数据库添加短信验证码失败') # else: # return jsonify(errno=RET.THIRDERR, errmsg='发送短信验证码失败') return jsonify(errno=RET.OK, errmsg='发送短信验证成功')
def register(): """ 1.获取参数 2.校验参数,为空校验 3.手机号格式校验 4.根枯手机号,去redis中取出短信验证码 5.判断短信验证码是否过期 6.删除reids的短信验证码 7.判断传入的短信验证码和redis中取出的是否一致 8.创建用户对象,设置属性 9.保存用户到数据库mysql 10.返回响应 :return: """ # 1.获取参数 # json_data = request.data # dict_data = json.loads(json_data) dict_data = request.json # 2.校验参数,为空校验 mobile = dict_data.get("mobile") sms_code = dict_data.get("sms_code") password = dict_data.get("password") # 3.手机号格式校验 if not re.match("1[35789]\d{9}", mobile): return jsonify(errno=RET.PARAMERR, 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(error=RET.DBERR, errmsg="短信验证码已过期") # 6.删除reids的短信验证码 try: redis_store.delete("sms_code:%s" % mobile) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="删除短信验证码异常") # 7.判断传入的短信验证码和redis中取出的是否一致 if sms_code != redis_sms_code: return jsonify(error=RET.DATAERR, errmsg="验证码输入错误") # 8.创建用户对象,设置属性 user = User() user.nick_name = mobile # user.password_hash = password # 需要加密处理 user.password = password user.mobile = mobile # 9.保存用户到数据库mysql 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="注册用户失败") # 10.返回响应 return jsonify(errno=RET.OK, errmsg="注册成功")
def register(): # 获取手机号,短信验证码,密码 json_data = request.json mobile = json_data.get('mobile') sms_code = json_data.get('smscode') password = json_data.get('password') # 校验参数是否完整 if not all([mobile, sms_code, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不全") try: real_sms_code = redis_store.get('SMS_' + mobile) # 数据类型:bytes real_sms_code = real_sms_code.decode() # 数据类型:str 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='验证码过期') # 校验短信验证码是否正确 if sms_code != real_sms_code: return jsonify(errno=RET.DATAERR, errmsg='验证码错误') try: # 删除奇景获取了的验证码 redis_store.delete('SMS_' + mobile) except Exception as e: current_app.logger.error(e) # 保存用户信息 user = User() # 创建模型类对象 # 添加数据 user.nick_name = mobile user.mobile = mobile user.password = password try: # 插入一条新对象 db.session.add(user) db.session.commit() # 提交到数据库 except Exception as e: current_app.loggert(e) return jsonify(errno=RET.DBERR, errmsg='数据库保存错误') # 记录最后一次登陆时间 try: user.last_login = datetime.now() db.session.commit() except Exception as e: current_app.logger.error(e) # 用session保存用户状态 session['user_id'] = user.id session['nick_name'] = user.nick_name session['mobile'] = user.mobile return jsonify(errno=RET.OK, errmsg='OK')
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 register(): """ 点击注册按钮,发起注册请求 :return: 返回注册结果, errno 和 errmsg """ # 1. 获取参数 params_dict = request.json if not params_dict: return jsonify(errno=RET.REQERR, errmsg="请求错误") mobile = params_dict.get("mobile") sms_code = params_dict.get("smscode") password = params_dict.get("password") # 2. 参数校验 # 非空校验 if not all([mobile, sms_code, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数错误") # 手机号正则验证 if not re.match(r"^1[3578]\d{9}$", mobile): return jsonify(errno=RET.DATAERR, errmsg="手机号格式不正确") # 3. 从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="数据库查询错误") if not real_sms_code: return jsonify(errno=RET.NODATA, errmsg="短信验证码过期") if real_sms_code != sms_code: return jsonify(errno=RET.DATAERR, errmsg="短信验证码输入错误") # 验证通过, 删除redis中的短信验证码 try: redis_store.delete("SMS_" + mobile) except Exception as e: current_app.logger.error(e) # 4. 初始化user模型, 并保存到数据库中 user = User() user.nick_name = mobile user.mobile = mobile # 保存密码, 自动调用propert装饰后的方法, 加密为passwor_hash user.password = password # 记录最近登录的时间 user.last_login = datetime.now() # 配置teardown后自动commit属性, 操作数据库后自动commit db.session.add(user) # 5. 记录用户登录状态到session session["user_id"] = user.id session["user_mobile"] = user.mobile session["user_nick_name"] = user.nick_name # 6. 返回注册结果 return jsonify(errno=RET.OK, errmsg="注册成功")
def register(): """ register user to database we need three parmas mobile numble,sms code and password """ data = request.json # get mobile , sms code and password mobile = data.get('mobile') sms_code = data.get('smscode') password = data.get('password') # if not all params if not all([mobile, sms_code, password]): return jsonify(error=RET.PARAMERR, errmsg='参数不全') # get real sms code from redis try: real_sms_code = redis_store.get('SMS_' + mobile) except Exception as e: current_app.logger.error(e) return jsonify(error=RET.DATAERR, errmsg='获取短信验证码失败') # determine sms whether None if not real_sms_code: return jsonify(RET.NODATA, errmsg='短信验证码已过期') # verify sms code whether true or false if sms_code != real_sms_code.decode(): return jsonify(RET.DATAERR, errmsg='短信验证码错误') # verify true try: redis_store.delete('SMS_' + mobile) except Exception as e: current_app.logger.error(e) # init user model user = User() user.nick_name = mobile user.mobile = mobile # password encryption user.password = password # storage user try: db.session.add(user) db.session.commit() except Exception as e: db.session.rollback() current_app.logger.error(e) return jsonify(RET.DATAERR, errmsg='用户保存错误') # keep login in web clent session['user_id'] = user.id session['nick_name'] = user.nick_name session['mobile'] = user.mobile # return response return jsonify(error=RET.OK, errmsg='ok')
def send_sms(): 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.DATAERR, errmsg='手机号输入有误') # 数据库查找用户信息,确认该手机号是否已注册 try: find_user = User.query.filter(User.mobile == mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="获取用户信息失败") if find_user: return jsonify(errno=RET.DATAEXIST, errmsg="用户已存在") try: redis_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 redis_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 redis_image_code.lower() != image_code.lower(): return jsonify(errno=RET.DATAERR, errmsg="验证码输入错误") smsCode = '%06d' % random.randint(0, 999999) try: redis_store.setex('SMS_'+mobile, constants.SMS_CODE_REDIS_EXPIRES, smsCode) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="sms验证码写入错误") try: cpp = sms.CCP() resp = cpp.send_template_sms(mobile, [smsCode, constants.SMS_CODE_REDIS_EXPIRES/60], 1) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.THIRDERR, errmsg="第三方接口错误") if resp == 0: return jsonify(errno=RET.OK) else: return jsonify(errno=RET.THIRDERR, errmsg='发送失败')
def sms_code(): # 1. 获取参数 # dict_data = request.json 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="参数验证不全") # 3. 验证手机号参数 if not re.match("1[35789]\d{9}", mobile): return jsonify(errno=RET.DATAERR, errmsg="手机号码格式错误") # 4. 通过验证码编号,取出图片验证码 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.DATAERR, errmsg="获取验证码失败") # 5. 判断验证码是否过期 if not redis_image_code: return jsonify(erron=RET.NODATA, errmsg="验证码不存在") # 6. 删除redis中的验证码 try: redis_store.delete("image_code:%s" % image_code_id) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.PWDERR, errmsg="获取验证码异常") # 7. 判断验证码和redis中的是否相等 if redis_image_code.lower() != image_code.lower(): return jsonify(errno=RET.DATAERR, errmsg="图片验证码不相等") # 8. 生成验证码 sms_code = "%06d" % random.randint(0, 999999) # 9. 通过ccp发送验证码 current_app.logger.debug(sms_code) # ccp = CCP() # try: # result = ccp.send_template_sms(mobile,[sms_code, constants.IMAGE_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="短信发送失败") # # 10. 存储验证码到redis中 try: redis_store.set("sms_code:%s" % mobile, sms_code, constants.IMAGE_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 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='参数缺失2') 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='图片验证码已过期') # 因为图片验证码只能让用户比较一次,redis只能get一次,所以要立即删除 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='图片验证码错误') # 判断手机号是否已注册 try: user = User.query.filter_by(mobile=mobile).first() except Exception as e: current_app.logger.error(e) return jsonify(enrro=RET.DATAERR, errmsg='查询数据库异常') else: if user is not None: return jsonify(enrro=RET.DATAEXIST, errmsg='手机号已经注册过') # 构造短信随机码,format() sms_code = '%06d' % random.randint(0, 999999) # 把短信随机数保存到redis数据库中 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 = sms.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 register(): """ 1. 获取参数和判断是否有值 2. 从redis中获取指定手机号对应的短信验证码的 3. 校验验证码 4. 初始化 user 模型,并设置数据并添加到数据库 5. 保存当前用户的状态 6. 返回注册的结果 :return: """ # 1,获取参数,校验参数 mobile = request.json.get('mobile') sms_code = request.json.get('smscode') password = request.json.get('password') print(sms_code) if not all([mobile, sms_code, password]): return jsonify(errno=RET.PARAMERR, errmsg='参数缺失') # 2.从redis中获取指定手机号对应的短信验证码的 try: # 从数据看获取的是二进制数据 real_sms_code = redis_store.get('SMS_' + mobile).decode() print(real_sms_code) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg='数据库查询失败') # 3.校验验证码 # 3.1判断是否过期 if not real_sms_code: return jsonify(errno=RET.NODATA, errmsg='验证码已过期') # 3.2判断验证码是否正确 if sms_code != real_sms_code: return jsonify(errno=RET.DATAERR, errmsg='短信验证码错误') # 3.3删除短信验证码 try: redis_store.delete('SMS_' + mobile) except Exception as e: current_app.logger.error(e) # 4. 初始化 user 模型,并设置数据并添加到数据库 user = User() user.nick_name = mobile user.mobile = mobile user.password = password # 4.1 保存到数据库 try: db.session.add(user) db.session.commit() except Exception as e: db.rollback() current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg='保存数据失败') # 5.保存当前用户的状态 session['user_id'] = user.id session['nick_name'] = user.nick_name session['mobile'] = user.mobile # 6.返回注册的结果 return jsonify(errno=RET.OK, errmsg='注册成功')
def register(): """ 1.接收参数:mobile,smscode,password 2.整体效验参数的完整性 3.手机号格式是否正确 4.从redis中通过手机号码取出真实的短信验证码 5.和用户输入的验证码比较 6.初始化User()添加数据 7.session保持用户登录状态 8.返回响应 :return: """ # 1 接收参数 dict_data = request.json mobile = dict_data.get("mobile") sms_code = dict_data.get("smscode") password = dict_data.get("password") # 2.整体效验参数的完整性 if not all([mobile, sms_code, password]): return jsonify(errno=RET.PARAMERR, errmsg="有参数为空") # 3.手机格式正确 if not re.match(r"1[35678][0-9]{9}$", mobile): return jsonify(errno=RET.DATAERR, errmsg="号码不符合") # 4.从redis中通过手机号码取出真实的短信验证码 try: real_sms_code = redis_store.get("SMS_" + mobile) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DATAERR, errmsg="获取本地验证码失败") if not real_sms_code: return jsonify(errno=RET.NODATA, errmsg="短信验证码过期") if sms_code != real_sms_code: return jsonify(errno=RET.DATAERR, errmsg="短信验证码不符合") # 删除短信验证码 try: redis_store.delete("SMS_" + mobile) except Exception as e: current_app.logger.error(e) # 5.初始化User()添加数据 user = User() user.nick_name = mobile # user.password_hash = password user.password = password # 暗密码 user.mobile = mobile try: db.session.add(user) db.session.commit() except Exception as e: db.session.rollback() current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="数据库保持失败") # 7 session保持用户登录状态 session["user_id"] = user.id 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 register(): ''' 1. 获取参数 2. 校验参数 3. 通过手机号码取出验证码 4. 判断验证码是否过期 5. 删除redis中的短信验证码 6. 判断验证码的正确性 7. 创建用户对象 8. 设置用户属性 9. 保存到数据库 10. 返回响应 :return: ''' dict_data = request.json mobile = dict_data.get('mobile') sms_code = dict_data.get('sms_code') password = dict_data.get('password') if not all([mobile, sms_code, password]): return jsonify(errno=RET.PARAMERR, errmsg="参数不全") 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="获取短信验证码异常") if not redis_sms_code: return jsonify(errno=RET.NODATA, errmsg="短信验证码已过期") try: redis_store.delete('sms_code:%s' % mobile) except Exception as e: current_app.logger.error(e) return jsonify(errno=RET.DBERR, errmsg="删除短信验证码异常") if redis_sms_code != sms_code: return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误") user = User() user.nick_name = mobile user.password = password user.mobile = mobile 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="用户注册失败") return jsonify(errno=RET.OK, errmsg="用户注册成功")