def save_order_comment(order_id):
"""
保存订单评论信息
前端传递参数:comment 格式json
:param order_id:订单id
:return: json
"""
# 获取用户id
user_id = g.user_id
# 接收参数
resp_dict = request.get_json()
comment = resp_dict.get("comment")
# 校验参数
if not comment:
return jsonify(errnum=RET.PARAMERR, errmsg=u"参数错误")
# 判断订单id是有效
try:
# 判断订单的id是否是接收的订单id, 该订单是否是待评价状态, 该订单是否是当前用户的订单
order = Order.query.filter(Order.id == order_id,
Order.status == "WAIT_COMMENT",
Order.user_id == user_id).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errnum=RET.DBERR, errmsg=u"获取订单信息失败")
if order is None:
return jsonify(errnum=RET.NODATA, errmsg=u"订单信息不存在")
# 业务处理
# 把订单状态改为已完成
order.status = "COMPLETE"
# 把订单的评价改为用户输入的评价
order.comment = comment
# 获取该订单的房屋
house = order.house
# 把房屋下的订单数量+1
house.order_count += 1
# 保存订单信息
try:
db.session.add(order)
db.session.add(house)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errnum=RET.DBERR, errmsg=u"保存数据失败")
# 为了方房屋详情页面的评价信息同步, 删除redis缓存
try:
redis_store.delete("house_info_%s" % user_id)
except Exception as e:
current_app.logger.error(e)
# 返回应答
return jsonify(errnum=RET.OK, errmsg=u"ok")
def get_sms_code(mobile):
"""获取短信"""
image_code = request.args.get("image_code")
image_code_id = request.args.get("image_code_id")
if not all([image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 取出code校验
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="redis error")
if real_image_code is None:
return jsonify(errno=RET.NODATA, errmsg="code older")
# remove verification code
try:
redis_store.delete("image_code_%s" % 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="code error")
# 判断是否发送过
try:
send_flag = redis_store.get("send_sms_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
return jsonify(errno=RET.REQERR, errmsg="time not achieve")
# 判断手机号是否存在
try:
user = User.query.filter_by(mobile=mobile).firs()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
return jsonify(errno=RET.DATAEXIST, errmsg="mobile exist")
# 生成短信验证码
sms_code = "%06d" % random.randint(0, 999999)
try:
redis_store.setex("sms_code_%s" % mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
#
redis_store.setex("send_sms_%s" % mobile,
constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="save sms code error")
# 发送短信西
try:
# ccp = CCP()
# result = ccp.send_template_sms(mobile, [sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
send_sms.delay(
mobile,
[sms_code, int(constants.SMS_CODE_REDIS_EXPIRES / 60)], 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="send error")
return jsonify(errno=RET.OK, errmsg="ok")
def save_order_comment(order_id):
"""保存订单评论信息"""
user_id = g.user_id
req_data = request.get_json()
comment = req_data.get("comment")
if not comment:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
order = Order.query.filter(Order.id == order_id, Order.user_id == user_id,
Order.status == "WAIT_COMMENT").first()
house = order.house
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="无法获取订单数据")
if not order:
return jsonify(errno=RET.REQERR, errmsg="操作无效")
try:
order.status = "COMPLETE"
order.comment = comment
house.order_count += 1
db.session.add(order)
db.session.add(house)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="操作失败")
try:
redis_store.delete("house_info_%s" % order.house.id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.OK, errmsg="OK")
def get_verify_code():
# 获取UUID
uuid = request.args.get('uuid')
if not uuid:
abort(403)
# 获取验证码信息
name, text, image = captcha.generate_captcha()
try:
if old_uuid:
# 删除之前的验证信息
redis_store.delete('Img_code:%s' % old_uuid)
redis_store.set('Img_code:%s' % uuid, text, constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify({'errcode': RET.DATAERR, 'errmsg': error_map[RET.DATAERR]})
global old_uuid
old_uuid = uuid
response = make_response(image)
response.headers['Content-Type'] = 'image/jpg'
current_app.logger.debug(text)
return response
def login():
"""登录模块"""
#获取参数,用户的手机号码,密码
req_dict = request.get_json()
mobile = req_dict.get("mobile")
password = req_dict.get("password")
#校验参数
if not all([mobile, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
#判断手机号码的格式是否正确
if not re.match(r"1[34578]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号码格式不正确")
# 判断用户的登录次数防止用户暴力破解密码
#从redis 中获取错误次数
user_ip = request.remote_addr
try:
access_counts = redis_store.get("access_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
else:
#如果有错误次数纪录,并且超过最大次数,直接返回
if access_counts is not None and int(
access_counts) >= constants.LOGIN_ERROR_MAX_NUM:
return jsonify(errno=RET.REQERR, errmsg="登录频繁")
#查询数据库,判断用户的信息与密码是否正确
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="用户信息查询失败")
if user is None or not user.check_password(password):
#出现错误,开始累加错误次数
try:
redis_store.incr("access_%s" % user_ip)
redis_store.expire("access_%s" % user_ip,
constants.LOGIN_ERROR_FORBID_TIME)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.LOGINERR, errmsg="用户名或者密码错误")
#登陆成功,设置session
#清除用户的登录错误次数
try:
redis_store.delete("access_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
#保存用户的登录状态
session["user_id"] = user.id
session["user_name"] = user.name
session["mobile"] = user.mobile
return jsonify(errno=RET.OK, errmsg="用户登录成功")
def get_image_code():
# 获取图片验证码 get请求
# 1.获取uuid作为存储验证码的key "image:uuid" : image_code
uuid = request.args.get('uuid')
last_uuid = request.args.get('last_uuid')
if not uuid:
return jsonify(errno=RET.PARAMERR, errmsg=u'缺少参数')
# 2.生成图片验证码
name,text,image = captcha.generate_captcha()
# 3.redis存储图片验证码
# 拼接redis存储的key
redis_key = 'image:%s' %uuid
try:
if last_uuid: # 如果存在上一个的uuid
redis_store.delete(last_uuid) # 删除多余的uuid
# key lavue 过期时间
redis_store.set(redis_key,text,constants.IMAGE_CODE_REDIS_EXPIRES) # 设置redis缓存
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR , errmsg=u'验证码保存失败')
# 4.返回图片验证码
response = make_response(image)
response.headers['Content-Type'] = 'image/jpg'
return response
def sms_code(mobile):
"""获取短信验证码"""
# 接收数据
image_code = request.args.get('image_code')
image_code_id = request.args.get('image_code_id')
# 校验数据
# 验证码数据是否存在
if not all([image_code, image_code_id]):
return jsonify(errcode=RET.DATAERR, errmsg='验证码信息不全')
try:
redis_code = redis_store.get('image_code_%s' % image_code_id)
redis_store.delete('image_code_%s' % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errcode=RET.DBERR, errmag='数据库信息错误')
if redis_code is None:
return jsonify(errcode=RET.NODATA, errmsg='验证码过期')
elif image_code.lower() != redis_code.lower():
return jsonify(errcode=RET.DATAERR, errmag='验证码错误')
# 业务逻辑处理
# 查询用户手机是否存在
try:
if User.query.filter_by(mobile=mobile).first():
return jsonify(errcode=RET.DATAEXIST, errmsg='手机号已被注册')
except Exception as e:
current_app.logger.error(e)
# 短信验证码
sms_codes = '%06d' % random.randint(0, 999999)
# 将短信验证码存入redis
try:
if redis_store.get('mobile_%s' % mobile) is None:
redis_store.setex('sms_code_%s' % mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_codes)
redis_store.setex('mobile_%s' % mobile, constants.SMS_SEND_TIME, 1)
else:
return jsonify(errcode=RET.DATAEXIST, errmsg='请求过于频繁，稍后再尝试')
except Exception as e:
current_app.logger.error(e)
return jsonify(errcode=RET.DBERR, errmag='数据库信息错误')
# 发送信息
try:
# 发送短信
sms_sender = CCP()
resp = sms_sender.sendTemplateSMS(mobile, [sms_codes, 5], 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errcode=RET.THIRDERR, errmsg='第三方系统错误')
# 返回
if resp:
return jsonify(errcode=RET.OK, errmsg='发送成功')
else:
return jsonify(errcode=RET.THIRDERR, errmsg='第三方系统错误')
def generate_image_code():
# 获取到之前的id和当前的id
pre_image_id = request.args.get('pre_id')
cur_image_id = request.args.get('cur_id')
# 生成验证码
name, text, image = captcha.generate_captcha()
current_app.logger.debug(text)
try:
# 删除之前的
redis_store.delete('ImageCode_' + pre_image_id)
# print "删除之前的验证码"
# 保存当前的
redis_store.set('ImageCode_' + cur_image_id, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
# print "保存当前的验证码"
except Exception as e:
current_app.logger.debug(e)
# 返回响应内容
# print '保存图片验证码失败' # for test
return make_response(jsonify(errno=RET.DATAERR, errmsg='保存图片验证码失败'))
else:
resp = make_response(image)
# 设置内容类型
resp.headers['Content-Type'] = 'image/jpg'
return resp
def get_image_code():
"""
1. 取到图片编码
2. 生成图片验证码
3. 存储到redis中(key是图片编码，值是验证码的文字内容)
4. 返回图片
"""
# 1. 取到图片编码
args = request.args
cur = args.get("cur")
pre = args.get("pre")
# 如果用户没有传图片id的话，直接抛错
if not cur:
abort(403)
# 2. 生成图片验证码
_, text, image = captcha.generate_captcha()
# 为了测试输入到控制台中
current_app.logger.debug(text)
# 3. 存储到redis中(key是图片编码，值是验证码的文字内容)
try:
if pre:
redis_store.delete("ImageCode_" + pre)
redis_store.set("ImageCode_" + cur, text,
constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存图片验证码失败")
# 4. 返回验证码图片
respnose = make_response(image)
# 设置contentType
respnose.headers["Content-type"] = "image/jpg"
return respnose
def get_sms_code():
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")
if not all([mobile, image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
if not re.match(r"1[34578]\d{9}", mobile):
return jsonify(errno=RET.DATAERR, errmsg="手机号格式不正确")
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="图片验证码获取失败")
try:
redis_store.delete("imge_code:%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
if image_code != redis_image_code:
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,
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 login():
"""
用户注册
参数：手机号 密码
格式：json
:return:
"""
# 获取参数
req_dict = request.get_json()
mobile = req_dict.get("mobile")
password = req_dict.get("password")
# 校验参数
# 参数完整的校验
if not all([mobile, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 手机号的格式
if not re.match(r"1[345678]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式错误")
# 判断错误次数是否超过限制，如果超过限制，则限制后续操作时间
# redis记录："acess_num_"请求的IP: 次数
user_ip = request.remote_addr # 用户的IP地址
try:
access_nums = redis_store.get("access_nums_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
else:
if access_nums is not None and int(access_nums) >= constants.LOGIN_ERROR_MAX_TIMES:
return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password):
# 如果验证失败，记录错误次数，反回信息
try:
redis_store.incr("access_nums_%s" % user_ip)
redis_store.expire("access_nums_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="用户名或密码错误")
# 如果验证相同成功，保存登录状态，在session中
session["name"] = user.name
session["mobile"] = user.mobile
session["user_id"] = user.id
# 登录成功删除redis登录错误次数记录
redis_store.delete("access_nums_%s" % user_ip)
return jsonify(errno=RET.OK, errmsg="登录成功")
def register():
resp_json = request.get_json
mobile = resp_json.get('mobile')
sms_code = resp_json.get('sms_code')
password = resp_json.get('password')
if not all([mobile, sms_code, password]):
return jsonify({'errno': RET.PARAMERR, 'errmsg': '参数不完整'})
if not re.match(r'1[34578]\d{9}', mobile):
return jsonify({'errno': RET.PARAMERR, 'errmsg': '不正确的手机号'})
try:
real_sms_code = redis_store.get('sms_code_' + mobile)
except Exception as e:
current_app.loger.error(e)
return jsonify({'errno': RET.DBERR, 'errmsg': '访问数据库异常'})
if real_sms_code is None:
return jsonify({'errno': RET.NODATA, 'errmsg': '短信验证已过期'})
if sms_code != real_sms_code:
return jsonify({'errno': RET.DATAERR, 'errmsg': '短信验证码输入错误'})
try:
redis_store.delete('sms_code_' + mobile)
except Exception as e:
logging.error(e)
user = User(name=mobile, mobile=mobile)
user.password = password
def register():
"""注册"""
# 获取参数
req_dict = request.get_json()
mobile = req_dict.get("mobile")
sms_code = req_dict.get("sms_code")
password = req_dict.get("password")
password2 = req_dict.get("password2")
# 校验参数
# 1. 参数完整性
if not all([mobile, sms_code, password, password2]):
return jsonify(errno=RET.PARAMERR, errmsg=u"参数不完整")
# 2. 手机号
if not re.match(r"1[34578]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg=u"手机号格式错误")
# 3. 密码
if password != password2:
return jsonify(errno=RET.PARAMERR, errmsg=u"两次密码不一致")
# 4. 短信验证码
try:
real_sms_code = redis_store.get("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u"读取短信验证码异常")
if real_sms_code is None:
return jsonify(errno=RET.NODATA, errmsg=u"短信验证码失效")
try:
# 删除redis中的短信验证码，防止重复使用校验
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
if real_sms_code != sms_code:
return jsonify(errno=RET.DATAERR, errmsg=u"短信验证码错误")
# 业务处理
# 1. 保存用户的注册数据到数据库中
user = User(name=mobile, mobile=mobile)
user.password = password # 设置属性，调用模型类中password.setter装饰方法
try:
db.session.add(user)
db.session.commit()
except IntegrityError as e:
# 模型类中设置mobile为unique，因此手机号若存在会在保存时抛出异常
db.session.rollback() # 回滚到异常commit提交前的状态
current_app.logger.error(e)
return jsonify(errno=RET.DATAEXIST, errmsg=u"手机号已存在")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u"查询数据库异常")
# 2. 保存登录状态到session中
session["name"] = mobile
session["mobile"] = mobile
session["user_id"] = user.id
# 返回结果
return jsonify(errno=RET.OK, errmsg=u"注册成功")
def register():
try:
req_data = request.get_json()
except Exception as e:
return jsonify(errno=RET.PARAMERR, errmsg='请传入json数据')
if not req_data:
return jsonify(errno=RET.PARAMERR, errmsg='请传入json数据')
mobile = req_data.get('mobile')
sms_code = req_data.get('sms_code')
password = req_data.get('password')
password2 = req_data.get('password2')
if not all([mobile, sms_code, password, password2]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
elif not re.match('1\d{10}', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误')
elif password != password2:
return jsonify(errno=RET.PARAMERR, errmsg='两次输入密码不相等')
try:
real_sms_code = redis_store.get('sms_code_%s' % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='redis数据库错误')
else:
if not real_sms_code:
return jsonify(errno=RET.NODATA, errmsg='短信验证码已过期')
elif real_sms_code != sms_code:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码错误')
# 删除redis中的短信验证码，防止重复使用校验
try:
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
# 保存用户的注册数据到数据库中
user = User(name=mobile, mobile=mobile)
# user.generate_password_hash(password)
user.password = password # 设置属性
try:
db.session.add(user)
db.session.commit()
except IntegrityError as e:
# 数据库操作错误后的回滚
db.session.rollback()
# 表示手机号出现了重复值，即手机号已注册过
current_app.logger.error(e)
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已存在")
except Exception as e:
db.session.rollback()
# 表示手机号出现了重复值，即手机号已注册过
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据库异常")
session['name'] = user.name
session['mobile'] = user.mobile
session['user_id'] = user.id
return jsonify(errno=RET.OK, errmsg='注册用户成功')
def register():
"""用户注册"""
# 从json中获取参数
user_data = request.get_json()
if not user_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
mobile = user_data.get("mobile") # 手机号
sms_code = user_data.get("sms_code") # 短信验证码
password = user_data.get("password") # 密码
# 检查参数
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 手机号格式校验
if not re.match(r"1[34578]\d{9}$", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确")
# 检查短信验证码
# 从redis中读取真实的短信验证码
try:
real_sms_code = redis_store.get("SMSCode_" + 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.DATAERR, errmsg="短信验证码过期")
# 判断用户输入的验证码的正确性
if real_sms_code != str(sms_code):
return jsonify(errno=RET.DATAERR, errmsg="短信验证码无效")
# 已经进行过短信验证码的对比校验，所以删除redis中的smscode
try:
redis_store.delete("SMSCode_" + mobile)
except Exception as e:
current_app.logger.error(e)
# 保存用户信息
user = User(name=mobile, mobile=mobile)
# 通过设置user模型的password属性，实际调用了设置密码的方法，对密码进行了加密
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.DATAEXIST, errmsg="手机号已存在")
# 保存用户的session数据
session["user_id"] = user.id
session["name"] = mobile
session["mobile"] = mobile
return jsonify(errno=RET.OK, errmsg="OK", data=user.to_dict())
def login():
'''登陆'''
# 获取参数,用户手机号,密码
req_dict = request.get_json()
mobile = req_dict.get('mobile')
password = req_dict.get('password')
# 校验参数
if not all([mobile, password]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 判读手机号格式
if not re.match(r'1[34578]\d{9}', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式不正确')
# 判断用户的错误次数,从redis中获取错误次数
user_ip = request.remote_addr
print(user_ip)
try:
access_counts = redis_store.get('access_%s' % user_ip)
except Exception as e:
current_app.logger.error(e)
else:
# 如果有错误次数记录,并且超过最大次数,直接返回
if access_counts is not None and int(
access_counts) > constants.LOGIN_ERROR_MAX_NUM:
return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password):
# 出现错误,累加错误次数
try:
redis_store.incr('access_%s' % user_ip)
redis_store.expire('access_%s' % user_ip,
constants.IMAGE_CODE_REDIS_EXPIRES)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.LOGINERR, errmsg='用户名或密码错误')
# 登陆成功,清除用户的登陆错误次数
try:
redis_store.delete('access_%s' % user_ip)
except Exception as e:
current_app.logger.error(e)
# 保存用户的登陆状态
session['user_id'] = user.id
session['user_name'] = user.name
session['mobile'] = user.mobile
return jsonify(errno=RET.OK, errmsg='用户登陆成功')
def login():
"""登录"""
# 获取参数、用户手机号 密码
req_dict = request.get_json()
mobile = req_dict.get("mobile")
password = req_dict.get("password")
# 检验参数
if not all([mobile, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 判断手机号格式
if not re.match(r"1[34578]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确")
# 判断用户的错误次数
# 从redis中获取错误次数
user_ip = request.remote_addr
try:
access_counts = redis_store.get("access_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
else:
# 如果有错误次数记录，并且超过最大次数，直接返回
if access_counts is not None and int(
access_counts) >= constants.LOGIN_ERROR_MAX_NUM:
return jsonify(errno=RET.REQERR, 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 is None or not user.check_password(password):
# 出现错误，累加错误次数
try:
redis_store.incr("access_%s" % user_ip)
redis_store.expire("access_%s" % user_ip,
constants.LOGIN_ERROR_FORBID_TIME)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.LOGINERR, errmsg="用户名或密码失败")
# 登录成功，
# 清除用户的登录错误次数
try:
redis_store.delete("access_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
# 保存用户的登录状态
session["user_id"] = user.id
session["user_name"] = user.name
session["mobile"] = user.mobile
return jsonify(errno=RET.OK, errmsg="用户登录成功")
def login():
"""登录"""
# 获取参数, 用户名 密码
req_dict = request.get_json()
mobile = req_dict.get("mobile")
password = req_dict.get("password")
# 校验参数
if not all([mobile, password]):
resp = {"error_code": RET.PARAMERR, "errmsg": "参数不完整"}
return jsonify(resp)
if not re.match(r"1[34578]\d{9}", mobile):
resp = {"error_code": RET.PARAMERR, "errmsg": "手机号格式错误"}
return jsonify(resp)
# 判断用户的错误次数
# 从redis中获取错误次数
user_ip = request.remote_addr
try:
access_count = redis_store.get("access_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
else:
if access_count is not None and int(
access_count) >= constants.LOGIN_ERROR_MAX_NUM:
return jsonify(error_code=RET.REQERR, errmsg="登录过于频繁")
# 业务处理
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
resp = {"error_code": RET.DBERR, "errmsg": "查询用户信息失败"}
return jsonify(resp)
if user is not None and user.check_password(password):
# 清除用户的登录错误此时
try:
redis_store.delete("access_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
# 记录用户的登录状态
session["user_id"] = user.id
session["username"] = user.name
session["mobile"] = mobile
resp = {"error_code": RET.OK, "errmsg": "登录成功"}
return jsonify(resp)
else:
try:
redis_store.incr("access_%s" % user_ip)
redis_store.expire("access_%s" % user_ip,
constants.LOGIN_ERROR_FORBID_TIME)
except Exception as e:
current_app.logger.error(e)
resp = {"error_code": RET.LOGINERR, "errmsg": "用户名或密码错误"}
return jsonify(resp)
def send_sms_code(mobile):
#获取参数,除了传递的mobile外,还有图片验证码（内容数据）text，图片验证码id(模板id)--id
image_code = request.args.get('text')
image_code_id = request.args.get('id')
#校验是否缺少参数,mobile,text,id
if not all([mobile, image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
#校验mobile手机号格式
if not re.match(r'1[3456789]\d{9}', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机格式错误')
#获取本地存储redis中存储的真实图片验证码
try:
real_image_code = redis_store.get('ImageCode_' + image_code_id)
#判断获取结果，放在try中，图片验证码是否过期
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询图片验证码失败')
#判断是否过期
if not real_image_code:
return jsonify(errno=RET.NODATA, errmsg='图片验证码过期')
#删除图片验证码,图片验证码只能操作一次
try:
redis_store.delete('ImageCode' + image_code_id)
except Exception as e:
current_app.logger.error(e)
#比较真实的图片验证码与获取的是否一致，不区分大小写
if real_image_code.lower() != image_code.lower():
return jsonify(errno=RET.DATAERR, errmsg='图片验证码错误')
#查询数据库，看手机号是否已经注册,也就是是否存在这个手机的用户
try:
user = User.query.filter_by(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 = '%06d' % random.randint(0, 999999)
try:
redis_store.setex('SMSCode_' + mobile,
constants.SMS_CODE_REDIS_EXPIRES, sms_code)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='保存短信验证码失败')
#调用云通讯扩展包发送短信，模板方法
try:
ccp = 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 0 == result:
return jsonify(errno=RET.OK, errmsg='发送成功')
else:
return jsonify(errno=RET.THIRDERR, errmsg='发送失败')
def get_sms_code(mobile):
"""
发送手机验证码
:param mobile:
:return:
"""
image_code = request.args.get("image_code")
image_code_id = request.args.get("image_code_id")
if not all([image_code, image_code_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
try:
redis_image_code = redis_store.get("image_code_%s" % image_code_id)
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库异常")
if redis_image_code is None:
return jsonify(errno=RET.NODATA, errmsg="验证码过期")
if redis_image_code.lower() != image_code.lower():
return jsonify(errno=RET.DATAERR, errmsg="验证码错误")
try:
# 判断在60秒内用户有没有发送过验证码，如果有表示用户请求频繁，拒绝处理
send_flg = redis_store.get("send_sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
else:
if send_flg is not None:
# 60秒内发送过验证码
return jsonify(errno=RET.REQERR, errmsg="请求过于平凡，请60秒后再试")
# 生成手机验证码信息
sms_code = "%06d" % random.randint(0, 999999)
try:
redis_store.setex("sms_code_%s" % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
redis_store.setex("send_sms_code_%s" % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存验证码异常")
try:
ccp = CCP()
result = ccp.send_template_sms(mobile, [sms_code, int(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 save_order_comment(order_id):
"""保存订单评论信息"""
# 一. 获取数据
user_id = g.user_id
# 获取参数
req_data = request.get_json()
# 尝试获取评价内容
comment = req_data.get("comment")
# 二. 校验参数
# 要求用户必须填写评论内容
if not comment:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 三. 业务逻辑处理
# 3.1 查询订单状态为待评价
try:
# 根据订单id/订单所属用户/订单状态为待评价状态
order = Order.query.filter(Order.id == order_id,
Order.user_id == user_id,
Order.status == "WAIT_COMMENT").first()
# 查询订单所属房屋
house = order.house
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="无法获取订单数据")
# 校验查询结果
if not order:
return jsonify(errno=RET.REQERR, errmsg="操作无效")
# 3.2 保存评价信息
try:
# 将订单的状态设置为已完成
order.status = "COMPLETE"
# 保存订单的评价信息
order.comment = comment
# 将房屋的完成订单数增加1,如果订单已评价,让房屋成交量加1
house.order_count += 1
# add_all可以一次提交多条数据db.session.add_all([order,house])
db.session.add(order)
db.session.add(house)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
# 提交数据,如果发生异常,进行回滚
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="操作失败")
# 3.3 缓存中存储的房屋信息,因为订单成交,导致缓存中的数据已经过期,所以,需要删除过期数据
try:
redis_store.delete("house_info_%s" % order.house.id)
except Exception as e:
current_app.logger.error(e)
# 四. 返回数据
return jsonify(errno=RET.OK, errmsg="OK")
def login():
"""用户登录"""
# 获取参数
req_data = request.get_json()
if not req_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
mobile = req_data.get("mobile")
password = req_data.get("password")
# 检查参数
if not all([mobile, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 手机号格式校验
if not re.match(r"^1[34578]\d{9}$", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式错误")
# 判断访问次数是否超过限制
try:
access_count = redis_store.get("access_%s" % request.remote_addr)
except Exception as e:
current_app.logger.error(e)
else:
if access_count is not None and int(
access_count) >= constants.LOGIN_ERROR_MAX_NUM:
return jsonify(errno=RET.REQERR, 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="数据库异常")
# 调用user模型中实现的检验用户密码的方法
if user is None or not user.check_password(password):
try:
redis_store.incr("access_%s" % request.remote_addr)
redis_store.expire("access_%s" % request.remote_addr,
constants.LOGIN_ERROR_LOCKED_TIME)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="手机号或密码错误")
# 删除访问次数记录
try:
redis_store.delete("access_%s" % request.remote_addr)
except Exception as e:
current_app.logger.error(e)
# 用户验证成功，保存用户的session数据
session["user_id"] = user.id
session["name"] = user.name
session["mobile"] = user.mobile
return jsonify(errno=RET.OK, errmsg="登录成功", data={"user_id": user.id})
def login():
"""登录"""
# 获取参数,手机号,密码
# 使用request.get_json 或 json.loads(request.data)将json数据转化为字典类型
req_dict = request.get_json()
# 获取手机号
mobile = req_dict.get("mobile")
# 获取密码
password = req_dict.get("password")
# 校验参数
# 判断数据是否完整
if not all([mobile, password]):
return jsonify(errno=RET.PARAMERR, errmsg="数据不完整")
# 判断手机格式是否正确
if not re.match(r"1[34578]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机格式不正确")
# 业务处理
# 判断用户的错误次数，从redis获取错误次数 remote_addr取出ip地址信息
user_ip = request.remote_addr
try:
access_count = redis_store.get("access_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
else:
# 如果错误记录超过最大次数，则直接返回
if access_count is not None and int(
access_count) >= constants.LOGIN_ERROR_MAX_NUM:
return jsonify(errno=RET.REQERR, errmsg="登录太过频繁,请稍后在登录")
# 用户的user用户名是否存在,密码是否一致
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询用户信息异常")
# 判断用户的user用户名是否存在,密码是否正确
if user is None or not user.check_password(password):
# 出现错误则累加错误次数,incr
try:
redis_store.incr("access_%s" % user_ip)
redis_store.expire("access_%s" % user_ip,
constants.LOGIN_ERROR_FORBID_TIME)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.LOGINERR, errmsg="用户登录失败")
# 登录成功,则清除用户登录错误次数
try:
redis_store.delete("access_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
# 记住用户当前的登录状态
session["user_name"] = user.name
session["user_id"] = user.id
session["mobile"] = user.mobile
# 返回数据 登录成功
return jsonify(errno=RET.OK, errmsg="登录成功")
def login():
#1.获取参数(手机号,密码)
req_json = request.data
req_dict = json.loads(req_json)
mobile = req_dict.get("mobile")
password = req_dict.get("password")
#2.校验参数
if not all([mobile, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
#验证手机号的格式
if not re.match(r"1[356789]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式有误")
#记录用户的登录次数
try:
ip = request.remote_addr #获取用户的ip
account = redis_store.get("access_%s" % ip)
except Exception as e:
current_app.logger.error(e)
else:
if account is not None and int(account) >= constants.LOGIN_ERROR_COUNT:
return jsonify(errno=RET.DBERR, errmsg="登录次数用完,请十分钟再试")
#3.根据手机号取出用户对象
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询异常")
#4.判断用户名,密码
if user is None or not user.check_password(password):
try:
redis_store.incr("access_%s" % ip)
redis_store.expire("access_%s" % ip, constants.LOGIN_ERROR_TIME)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="用户名或者密码错误")
#登录成功,清除redis中的登录错误次数
try:
redis_store.delete("access_%s" % ip)
except Exception as e:
current_app.logger.error(e)
#5.记录用户的登录状态
session["user_id"] = user.id
session["user_name"] = user.name
session["mobile"] = user.mobile
#6.响应
return jsonify(errno=RET.OK, errmsg="登录成功")
def login():
# 获取参数
resp_json = request.get_json()
mobile = resp_json.get('mobile')
password = resp_json.get('password')
# 参数校验
# 1 数据完整性
if not all([mobile, password]):
return jsonify(errno=RET.PARAMERR, errmsg='数据不完整')
# 2 手机号格式
if not re.match(r"1[345678]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式不正确')
# 业务处理
# 用户ip
user_ip = request.remote_addr
try:
real_count = redis_store.get('access_' + user_ip)
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询Redis失败')
# Redis存储错误次数 不大于5次
if real_count and int(real_count) >= constants.LOGIN_ERROR_MAX_NUM:
return jsonify(errno=RET.REQERR, errmsg='请求已超过最大次数')
# 用户名是否存在
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='用户查询失败')
# 用户是否存在或者密码是否正确
if user is None or not user.check_password(password):
# 错误一次加一 设置过期时间
try:
redis_store.incr('access_' + user_ip)
redis_store.expire('access_' + user_ip, constants.LOGIN_ERROR_FORBID_TIME)
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='Redis操作失败')
return jsonify(errno=RET.LOGINERR, errmsg='用户名或密码输入错误')
# 如果输入正确 错误次数清零
try:
redis_store.delete('access_' + user_ip)
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='删除Redis数据失败')
# 保存登录状态
try:
session['id'] = user.id
session['name'] = user.mobile
session['mobile'] = user.mobile
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='用户登录失败')
# 返回数据
return jsonify(errno=RET.OK, errmsg='用户登录成功')
def register():
"""register
:return:
"""
req_dict = request.get_json()
mobile = req_dict.get("mobile")
sms_code = req_dict.get("sms_code")
pwd = req_dict.get("password")
pwd2 = req_dict.get("password2")
# 数据是否完整
if not all([mobile, sms_code, pwd]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 判断手机格式
if not re.match(r"1[34578]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机格式错误")
if pwd != pwd2:
return jsonify(errno=RET.PARAMERR, errmsg="两次密码不一致")
# 判断短信验证码是否正确
try:
real_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 real_sms_code is None:
return jsonify(errno=RET.NODATA, errmsg="短信验证码失效")
try:
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
# 验证码是否正确
if real_sms_code != sms_code:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误")
# 保存用户信息
user = User(name=mobile, mobile=mobile)
user.password = pwd
try:
db.session.add(user)
db.session.commit()
except IntegrityError as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="手机号存在")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库异常")
# 保存登录数据
session["name"] = mobile
session["mobile"] = mobile
session["user_id"] = user.id
# return
return jsonify(errno=RET.OK, errmsg="ok")
def login():
'''登陆'''
# 获取参数
req_dict = request.get_json()
mobile = req_dict.get("mobile")
password = req_dict.get("password")
# 校验参数
if not all([mobile, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 判断手机号格式
if not re.match(r"1[34578]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg="手机号格式不正确")
# 业务逻辑
user_ip = request.remote_addr
try:
# 获取登陆失败的次数
access_count = redis_store.get("access_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
print access_count
if access_count is not None and int(access_count) >= constants.ACCESS_LOGIN_MAX_NUM:
return jsonify(errno=RET.REQERR, 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 is None or not user.chek_password(password):
try:
# 账号密码错误时，自增1
redis_store.incr("access_%s" % user_ip)
# 设置过期时间
redis_store.expire("access_%s" % user_ip, constants.ACCESS_LOGIN_TIME)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="用户名或密码错误")
try:
# 清除redis错误时登陆次数
redis_store.delete("access_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
# 登陆成功
# 记录用户会话消息
session["user_id"] = user.id
session["user_name"] = user.name
session["user_mobile"] = user.mobile
# 返回
return jsonify(errno=RET.OK, errmsg="登陆成功")
def generate_image_code(image_code_id):
"""
生成图片验证码:
1/调用captcha扩展包,生成图片验证码,name,text,image
2/本地存储图片验证码,使用redis数据库
3/返回图片本身,设置响应的content-type
4/调用make_response
:param image_code_id:
:return:
"""
# 调用captcha扩展包
name, text, image = captcha.generate_captcha()
# 调用redis数据库实例，存储图片验证码
# 删除上一个保持在redis数据库中的图片验证码
try:
code_image = request.cookies.get('image_code')
except Exception as e:
current_app.logger.error(e)
else:
if code_image:
try:
redis_store.delete('ImageCode_'+str(code_image)) # code_image没有类型要转成字符串
except Exception as e:
current_app.logger.error(e)
try:
# 调用redis数据库实例，存储图片验证码
# setex存储数据的类型及格式
# setex存储数据的类型是string 基本格式setex('key','timeout(过期时间)','values(值)')
redis_store.setex('ImageCode_'+ image_code_id, constants.IMAGE_CODE_REDIS_EXPIRES, text)
except Exception as e:
# 调用应用上下文,记录项目错误日志信息
current_app.logger.error(e)
# 以application/json的形式返回错误状态码,错误信息
return jsonify(errno=RET.DBERR,errmsg='保存图片验证失败')
# 如果未发生异常，返回图片本身
else:
# 使用响应对象，用来返回图片
response = make_response(image)
# 设置响应报文的Content-Type = 'image/jpg'
response.headers['Content-Type'] = 'image/jpg'
# response对象删除上一个保持在浏览器cookie中的图片验证码
try:
response.delete_cookie('image_code')
except Exception as e:
pass
# 新的验证码存入cookie
response.set_cookie('image_code', image_code_id)
# 返回响应response
return response
def register():
"""
注册
请求参数 手机号 验证码 秘密 确认密码
请求方式 json
:return:
"""
req_data = request.get_json()
mobile = req_data.get("mobile")
sms_code = req_data.get("sms_code")
password = req_data.get("password")
password2 = req_data.get("password2")
if not all([mobile, sms_code, password, password2]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
if password != password2:
return jsonify(errno=RET.PARAMERR, errmsg="两次秘密不一样")
if not re.match(r'1[34678]\d{9}', mobile):
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 redis_sms_code is None:
return jsonify(errno=RET.NODATA, errmsg="手机验证码失效")
try:
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
if sms_code != redis_sms_code:
return jsonify(errno=RET.DATAERR, errmsg="验证码不对")
user = User(name=mobile, mobile=mobile)
user.password = password
try:
db.session.add(user)
db.session.commit()
except IntegrityError as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DATAEXIST, errmsg="手机号已经存在")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询异常")
session["name"] = mobile
session["mobile"] = mobile
session["user_id"] = user.id
return jsonify(errno=RET.OK, errmsg="注册成功")
def login():
""""登陆参数：手机号，密码"""
# 1. 获取参数
req_dict = request.get_json()
mobile = req_dict.get("mobile")
password = req_dict.get("password")
# 2. 校验参数
# 2.1 参数完整性
if not all([mobile, password]):
return jsonify(errno=RET.PARAMERR, errmsg='请输入用户名和密码')
# 2.2 手机号格式是否正确,re.match成功返回字符串，失败返回None
if not re.match(r'1[34578]\d{9}', mobile):
return jsonify(errno=RET.DATAERR, errmsg='手机号格式错误')
# 2.3 判断用户操作是否超过限制
# redis记录："access_nums_%s" % user_ip: nums
user_ip = request.remote_addr # 获取用户的IP地址
try:
access_nums = redis_store.get("access_nums_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
else:
if access_nums is not None and int(access_nums) >= LOGIN_ERROR_TIMES:
return jsonify(errno=RET.REQERR, errmsg='登陆次数过多，请稍后重试')
# 3. 业务处理
# 3.1 获取用户对象
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="用户名或密码错误")
# 3.2 如果获取的为空 / 密码校验错误
if user is None or not user.check_password(password):
# 记录错误次数
try:
redis_store.incr("access_nums_%s" % user_ip)
redis_store.expire("access_nums_%s" %
LOGIN_ERROR_FORBIN_TIME) # 设置数据有效期
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='用户名或密码错误')
# 4. 返回应答
# 4.1 保存登录状态
session['name'] = user.name
session['mobile'] = user.mobile
session['user_id'] = user.id
# 4.2 消除错误登陆次数
redis_store.delete("access_nums_%s" % user_ip)
# 4.3 返回应答
return jsonify(errno=RET.OK, errmsg='登陆成功')
def save_order_comment(order_id):
"""保存评论信息
参数：订单编号
"""
# 获取用户 id
user_id = g.user_id
# 获取参数
req_data = request.get_json()
comment = req_data.get("comment")
if not comment:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 根据订单编号,检验该订单是自己下的订单,并且处于待评论的状态, 否则不予许评论
try:
order = Order.query.filter(Order.id == order_id,
Order.user_id == user_id,
Order.status == 'COMPLETE').first()
house = order.house
print(house)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='无法获取订单数据')
if not order:
return jsonify(errno=RET.REQERR, errmsg='无法操作')
# 保存评论
try:
# 修改订单状态为"已完成"
order.status = 'COMPLETE'
# 添加评论内容
order.comment = comment
# 房子表中该房子被订单数量加 1
house.order_count += 1
# 提交
db.session.add(order)
db.session.add(house)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='操作失败')
# 因为房屋详情中有订单的评价信息，为了让最新的评价信息展示在房屋详情中，所以删除redis中关于本订单房屋的详情缓存
try:
redis_store.delete("house_info_%s" % order.house.id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.OK, errmsg='OK')
def save_order_comment(order_id):
"""保存订单评论信息"""
user_id = g.user_id
# 获取参数
req_data = request.get_json()
comment = req_data.get("comment") # 评价信息
# 检查参数
if not comment:
return jsonify(error_code=RET.PARAMERR, errmsg="参数错误")
try:
# 需要确保只能评论自己下的订单，而且订单处于待评价状态才可以
order = Order.query.filter(Order.id == order_id, Order.user_id == user_id,
Order.status == "WAIT_COMMENT").first()
house = order.house
except Exception as e:
current_app.logger.error(e)
return jsonify(error_code=RET.DBERR, errmsg="无法获取订单数据")
if not order:
return jsonify(error_code=RET.REQERR, errmsg="操作无效")
try:
# 将订单的状态设置为已完成
order.status = "COMPLETE"
# 保存订单的评价信息
order.comment = comment
# 将房屋的完成订单数增加1
house.order_count += 1
db.session.add(order)
db.session.add(house)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(error_code=RET.DBERR, errmsg="操作失败")
# 因为房屋详情中有订单的评价信息，为了让最新的评价信息展示在房屋详情中，所以删除redis中关于本订单房屋的详情缓存
try:
redis_store.delete("house_info_%s" % order.house.id)
except Exception as e:
current_app.logger.error(e)
return jsonify(error_code=RET.OK, errmsg="OK")
def register():
"""
注册
1/获取参数,使用user_data = request.get_json()
2/校验参数的存在
3/进一步获取详细的参数信息,mobile,smscode,password
4/校验参数的完整性
5/进一步校验详细的参数信息,mobile
6/校验短信验证码,获取本地存储的短信验证码
7/判断短信验证码是否过期
8/比较短信验证码是否正确
9/删除短信验证码
10/判断用户是否已注册
11/保存用户信息,
user = User(mobile=mobile,name=mobile)
user.password = password
12/缓存用户信息:flask_session扩展包的作用:指定用户的缓存信息存放位置,加密签名,指定有效期;
我们需要使用请求上下文对象session来从redis中获取或设置用户信息;
session.get('user_id')
session[user_id] = user_id
13/返回结果
:return:
"""
# 获取参数
user_data = request.get_json()
# 判断获取结果
if not user_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 进一步获取详细的参数信息
mobile = user_data.get('mobile')
smscode = user_data.get('sms_code')
password = user_data.get('password')
# 校验参数的完整性
if not all([mobile, smscode, password]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 校验手机号格式是否符合要求
if not re.match(r'1[3456789]\d{9}$', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式错误')
# 校验短信验证码,从redis中获取真实的短信验证码
try:
real_sms_code = redis_store.get('SMSCode_' + 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 != str(smscode):
return jsonify(errno=RET.DATAERR, errmsg='短信验证码错误')
# 删除短信验证码
try:
redis_store.delete('SMSCode_' + mobile)
except Exception as e:
current_app.logger.error(e)
# 判断用户是否已注册
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询用户信息异常')
else:
if user is not None:
return jsonify(errno=RET.DATAEXIST, errmsg='手机号已注册')
# 调用模型类对象，保存用户信息
user = User(mobile=mobile, name=mobile)
# 对密码存储,这里调用了模型类generate_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['user_id'] = user.id
session['name'] = mobile
session['mobile'] = mobile
# 返回结果，data 为附属消息
return jsonify(errno=RET.OK, errmsg='OK', data=user.to_dict())
def send_sms_code(mobile):
"""发送短信验证码"""
# 获取参数
image_code_id = request.args.get("image_code_id")
image_code = request.args.get("image_code")
# 校验参数
if not all([image_code_id, image_code]):
resp = {
"error_code": RET.PARAMERR,
"errmsg": "参数不完整"
}
return jsonify(resp)
# 业务处理
# 取出真实的图片验证码
try:
real_image_code = redis_store.get("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
resp = {
"error_code": RET.DBERR,
"errmsg": "获取图片验证码失败"
}
return jsonify(resp)
# 判断验证码的有效期
if real_image_code is None:
resp = {
"error_code": RET.NODATA,
"errmsg": "图片验证码过期"
}
return jsonify(resp)
# 删除redis中的图片验证码，防止用户多次尝试同一个图片验证码
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
# 判断用户填写的验证码与真实验证码
if real_image_code.lower() != image_code.lower():
# 表示用户填写错误
resp = {
"error_code": RET.DATAERR,
"errmsg": "图片验证码有误"
}
return jsonify(resp)
# 判断用户手机号是否注册过
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
resp = {
"error_code": RET.DATAEXIST,
"errmsg": "手机号已注册过"
}
return jsonify(resp)
# 创建短信验证码
sms_code = "%06d" % random.randint(0, 999999)
# 保存短信验证码
try:
redis_store.setex("sms_code_%s" % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
except Exception as e:
current_app.logger.error(e)
resp = {
"error_code": RET.DBERR,
"errmsg": "保存短信验证码异常"
}
return jsonify(resp)
# 发送验证码短信
# 通过celery发送
# task_sms.send_template_sms.delay(mobile, [sms_code, str(constants.SMS_CODE_REDIS_EXPIRES/60)], 1)
# result返回异步结果对象， 通过对象能够获取最终执行结果
result = tasks.send_template_sms.delay(mobile, [sms_code, str(constants.SMS_CODE_REDIS_EXPIRES/60)], 1)
# 通过get方法能返回执行结果
# get()默认是阻塞的, 会等到worker执行完成有了结果的时候才返回
# get()通过timeout超时时间，可以在超过超时时间后立即返回
ret = result.get()
print ret
return jsonify(error_code=RET.OK, errmsg="ok")
def get_sms_codes(mobile):
# 获取参数
code = request.args.get('code')
codeId = request.args.get('codeId')
# 参数校验
if not all([code, codeId]):
resp = {
'errno': RET.DATAERR,
'errmsg': '数据不完整'
}
return jsonify(resp)
# 业务处理
# 2 获取图片验证码
image_code_id = 'image_code_' + codeId
try:
new_code = redis_store.get(image_code_id)
except Exception as e:
logging.error(e)
resp = {
'errno': RET.DBERR,
'errmsg': '获取图片验证码失败'
}
return jsonify(resp)
# 图片验证码是否有效
if new_code is None:
resp_dict = {
'errno': RET.NODATA,
'errmsg': '图片验证码过期/失效'
}
return jsonify(resp_dict)
# 删除原来的验证码
try:
redis_store.delete(image_code_id)
except Exception as e:
logging.error(e)
resp = {
'errno': RET.DBERR,
'errmsg': '删除图片验证码失败'
}
return jsonify(resp)
# 3 对比是否一致
if new_code.lower() != code.lower():
# 不一致
resp = {
'errno': RET.PARAMERR,
'errmsg': '图片二维码填写错误，请点击刷新后重新输入'
}
return jsonify(resp)
# 1 用户名是否存在
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
logging.error(e)
resp = {
'errno': RET.DBERR,
'errmsg': '查找用户信息失败'
}
return jsonify(resp)
if user:
# 用户存在
resp = {
'errno': RET.DATAEXIST,
'errmsg': '该用户已存在'
}
return jsonify(resp)
# 创建6位验证码
sms_code = '%06d' % random.randint(0, 999999)
# 将短信验证码存储到Redis中 点击注册时进行对比
try:
redis_store.setex('sms_code_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRE, sms_code)
except Exception as e:
logging.error(e)
resp = {
'errno': RET.DBERR,
'errmsg': '保存短信验证码失败'
}
return jsonify(resp)
# 发送验证码
ccp = CCP()
status_code = ccp.send_template_sms('18204681825', [sms_code, constants.SMS_CODE_TIME_EXPIRE], 1)
# 返回数据
if status_code == '000000':
resp = {
'errno': RET.OK,
'errmsg': '发送短信验证码成功'
}
return jsonify(resp)
else:
resp = {
'errno': RET.THIRDERR,
'errmsg': '发送短信验证码失败'
}
return jsonify(resp)
def login():
"""登录"""
# 获取参数, 用户名 密码
req_dict = request.get_json()
mobile = req_dict.get("mobile")
password = req_dict.get("password")
# 校验参数
if not all([mobile, password]):
resp = {
"error_code": RET.PARAMERR,
"errmsg": "参数不完整"
}
return jsonify(resp)
if not re.match(r"1[34578]\d{9}", mobile):
resp = {
"error_code": RET.PARAMERR,
"errmsg": "手机号格式错误"
}
return jsonify(resp)
# 判断用户的错误次数
# 从redis中获取错误次数
user_ip = request.remote_addr
try:
access_count = redis_store.get("access_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
else:
if access_count is not None and int(access_count) >= constants.LOGIN_ERROR_MAX_NUM:
return jsonify(error_code=RET.REQERR, errmsg="登录过于频繁")
# 业务处理
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
resp = {
"error_code": RET.DBERR,
"errmsg": "查询用户信息失败"
}
return jsonify(resp)
if user is not None and user.check_password(password):
# 清除用户的登录错误此时
try:
redis_store.delete("access_%s" % user_ip)
except Exception as e:
current_app.logger.error(e)
# 记录用户的登录状态
session["user_id"] = user.id
session["username"] = user.name
session["mobile"] = mobile
resp = {
"error_code": RET.OK,
"errmsg": "登录成功"
}
return jsonify(resp)
else:
try:
redis_store.incr("access_%s" % user_ip)
redis_store.expire("access_%s" % user_ip, constants.LOGIN_ERROR_FORBID_TIME)
except Exception as e:
current_app.logger.error(e)
resp = {
"error_code": RET.LOGINERR,
"errmsg": "用户名或密码错误"
}
return jsonify(resp)
def register():
"""用户注册"""
# 接收参数，手机号 短信验证码 密码
req_dict = request.get_json()
mobile = req_dict.get("mobile")
sms_code = req_dict.get("sms_code")
password = req_dict.get("password")
# 校验参数
if not all([mobile, sms_code, password]):
resp = {
"error_code": RET.PARAMERR,
"errmsg": "参数不完整"
}
return jsonify(resp)
if not re.match(r"1[34578]\d{9}", mobile):
resp = {
"error_code": RET.DATAERR,
"errmsg": "手机号格式错误"
}
return jsonify(resp)
# 业务处理
# 获取真实的短信验证码
try:
real_sms_code = redis_store.get("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
resp = {
"error_code": RET.DBERR,
"errmsg": "查询短信验证码错误"
}
return jsonify(resp)
# 判断短信验证码是否过期
if real_sms_code is None:
resp = {
"error_code": RET.NODATA,
"errmsg": "短信验证码已过期"
}
return jsonify(resp)
# 判断用户输入的短信验证码是否正确
if real_sms_code != sms_code:
resp = {
"error_code": RET.DATAERR,
"errmsg": "短信验证码错误"
}
return jsonify(resp)
# 删除短信验证码
try:
redis_store.delete("sms_code_%s" % mobile)
except Exception as e:
current_app.logger.error(e)
# 判断手机号是否已经注册
# try:
# user = User.query.filter_by(mobile=mobile).first()
# except Exception as e:
# current_app.logger.error(e)
# resp = {
# "error_code": RET.DBERR,
# "errmsg": "数据库异常"
# }
# return jsonify(resp)
#
# if user is not None:
# resp = {
# "error_code": RET.DATAEXIST,
# "errmsg": "手机号已经注册"
# }
# return jsonify(resp)
# 保存用户的数据到数据库中
user = User(name=mobile, mobile=mobile)
# 对于password属性的设置，会调用属性方法
user.password = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
resp = {
"error_code": RET.DATAEXIST,
"errmsg": "手机号已经注册"
}
return jsonify(resp)
# 记录用户的登录状态
session["user_id"] = user.id
session["username"] = mobile
session["mobile"] = mobile
# 返回响应
resp = {
"error_code": RET.OK,
"errmsg": "注册成功"
}
return jsonify(resp)
def register():
# 获取参数
resp_json = request.get_json()
mobile = resp_json.get('mobile')
sms_code = resp_json.get('sms_code')
password = resp_json.get('password')
# 参数校验
# 1 数据完整性
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg='数据不完整')
# 2 手机号格式
if not re.match(r"1[345678]\d{9}", mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号格式不正确')
# 业务处理
# Redis中取出短信验证码
try:
real_sms_code = redis_store.get('sms_code_' + mobile)
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='获取Redis数据错误')
# 短信验证码是否失效
if not real_sms_code:
return jsonify(errno=RET.DATAERR, errmsg='短信验证码过期或不存在')
# 对比短信验证码是否一致
if real_sms_code != sms_code:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码输入错误，请重新输入')
# 删除短信Redis--》可以修改后重新输入
try:
redis_store.delete('sms_code_' + mobile)
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='删除Redis数据错误')
# 查询用户是否存在
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='用户表查询失败')
if user:
return jsonify(errno=RET.DATAEXIST, errmsg='该用户已注册，请去登录')
# 将用户信息保存到数据库中
user = User(name=mobile, mobile=mobile)
# 密码需要加密
user.password = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
logging.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='添加用户失败')
# 保存用户登录状态并跳转到登录页
try:
session['id'] = user.id
session['name'] = user.mobile
session['mobile'] = user.mobile
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='session存储错误')
# 返回数据
return jsonify(errno=RET.OK, errmsg='用户注册成功')
def send_sms_code(mobile):
"""
1/获取参数,mobile,text,id,request.args.get('text')
2/校验参数的完整性
3/校验手机号,正则表达式校验手机号格式
4/校验图片验证码,操作redis数据库,获取本地存储的真实图片验证码
5/校验获取结果,判断真实的图片验证码是否存在
6/删除redis中的图片验证码
7/比较图片验证码是否一致
8/生成短信验证码,'%06d' % random.randint(1,999999)生成随机数
9/在本地存储短信验证码,存redis中
10/判断手机号是否已注册
11调用云通讯接口,发送短信,send_template_sms(mobile,sms_coce,time,tempID)
12/保存发送结果,判断发送是否成功
13/返回结果
:param mobile:
:return:
"""
# 获取参数
image_code = request.args.get('text')
image_code_id = request.args.get('id')
# 校验参数的完整性
if not all([mobile, image_code_id, image_code]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 校验手机号码的格式
if not re.match(r'1[3456789]\d{9}', mobile):
return jsonify(errno=RET.PARAMERR, errmsg='手机号码格式不正确')
# 校验图片验证码，从redis中获取
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='图片验证码错误')
# 开始准备发送短信验证码
sms_code = '%06d'% random.randint(1, 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:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='获取用户的信息失败')
else:
# 判断用户是否已经存在
if user is not None:
return jsonify(errno=RET.DATAEXIS,errmsg='用户已经存在')
# 调用云通讯接口发送短信
try:
cpp = sms.CCP()
# 发送短信的模板方法会有返回值，0 表示发送成功
result = cpp.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='发送失败')
