def get_houses_area():
'''获取城区信息'''
try:
resp = redis_store.get("area_info").decode()
print(type(resp))
except Exception as e:
current_app.logger.error(e)
else:
if resp is not None:
current_app.logger.info("hit redis area_info")
return resp, 200, {"Content-Type": "application/json"}
try:
area_li = Area.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(error=RET.DATAERR, errmsg="数据库异常")
area_dict_li = []
for area in area_li:
area_dict_li.append(area.to_dict())
# 将数据转化为json
resp_dict = dict(error=RET.OK, errmsg="OK", data=area_dict_li)
resp_json = json.dumps(resp_dict)
# 将数据保存到redis中
try:
redis_store.setex("area_info", AREA_REDIS_CACHE_TIME, resp_json)
except Exception as e:
current_app.logger.error(e)
return resp_json, 200, {"Content-Type": "application/json"}
def get_houses_index():
'''
获取主页幻灯片展示的房屋基本信息
参数:房屋图片路由,从数据库获取,访问七牛云
redis
'''
# 从缓存中尝试获取数据
try:
resp = redis_store.get("home_page_data")
except Exception as e:
current_app.logger.error(e)
resp = None
if resp is not None:
current_app.logger.info("hit house index info redis")
# 因为redis中保存的是json字符串，所以直接进行字符串拼接返回
return '{"error":0, "errmsg":"OK", "data":%s}' % resp.decode(), 200, {
"Content-Type": "application/json"
}
else:
# 查询数据库，返回房屋订单数目最多的5条数据
try:
houses = House.query.order_by(
House.order_count.desc()).limit(HOME_PAGE_MAX_HOUSES)
# houses=House.query.all()[1].user_id
except Exception as e:
current_app.logger.error(e)
return jsonify(error=RET.DBERR, errmsg="查询数据失败")
if not houses:
return jsonify(error=RET.NODATA, errmsg="查询无数据")
print("-----------1===-----------")
print("-----------%s_______------" % houses)
print("-----------2===-----------")
houses_li = []
for house in houses:
# 如果房屋未设置主图片，则跳过
if not house.index_image_url:
continue
houses_li.append(house.to_basic_dict())
print("-----------1===-----------")
print("-----------%s_______------" % houses_li)
print("-----------2===-----------")
# 将数据转换为json，并保存到redis缓存
house_json = json.dumps(houses_li)
try:
redis_store.setex("home_page_data", HOUSES_REDIS_CACHE_TIME,
house_json)
except Exception as e:
current_app.logger.error(e)
print("-----------1===-----------")
print("-----%s_______------" % house_json)
print("-----------2===-----------")
return '{"error":0, "errmsg":"OK", "data":%s}' % house_json, 200, {
"Content-Type": "application/json"
}
def get_houses_detail(house_id):
"""获取房屋详情"""
# 前端在房屋详情页面展示时，如果浏览页面的用户不是该房屋的房东，则展示预定按钮，否则不展示，
# 所以需要后端返回登录用户的user_id
# 尝试获取用户登录的信息，若登录，则返回给前端登录用户的user_id，否则返回user_id=-1
user_id = session.get("user_id", "-1")
# 校验参数
if not house_id:
return jsonify(error=RET.PARAMERR, errmsg="参数确实")
# 先从redis缓存中获取信息
try:
ret = redis_store.get("house_info_%s" % house_id).decode()
except Exception as e:
current_app.logger.error(e)
ret = None
if ret:
current_app.logger.info("hit house info redis")
return '{"error":"0", "errmsg":"OK", "data":{"user_id":%s, "house":%s}}' % (
user_id, ret), 200, {
"Content-Type": "application/json"
}
# 查询数据库
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(error=RET.DBERR, errmsg="查询数据失败")
if not house:
return jsonify(error=RET.NODATA, errmsg="房屋不存在")
# 将房屋对象数据转换为字典
try:
house_data = house.to_full_dict()
except Exception as e:
current_app.logger.error(e)
return jsonify(error=RET.DATAERR, errmsg="数据出错")
# 存入到redis中
json_house = json.dumps(house_data)
try:
redis_store.setex("house_info_%s" % house_id, HOUSES_REDIS_CACHE_TIME,
json_house)
except Exception as e:
current_app.logger.error(e)
resp = '{"error":"0", "errmsg":"OK", "data":{"user_id":%s, "house":%s}}' % (
user_id, json_house), 200, {
"Content-Type": "application/json"
}
return resp
def login():
'''
用户登录
参数:手机号,密码,
格式:json
'''
request_dict = request.get_json()
mobile = request_dict.get("mobile")
pwd = request_dict.get("password")
print("---%s---%s---" % (mobile, pwd))
if not all([mobile, pwd]):
return jsonify(error=RET.PARAMERR, errmsg="参数不完整")
# 判断手机号格式
if not re.match(r"1[3-9]\d{9}", mobile):
# 格式错误
return jsonify(error=RET.PARAMERR, errmsg="手机格式错误")
# 判断错误次数是否超过限制次数,如果超过限制,返回
# redis记录:"access_token_用户请求的ip地址":次数
user_ip = request.remote_addr #获取用户ip地址
try:
access_nums = redis_store.get("access_num_%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_NUMBER:
return jsonify(error=RET.REQERR, 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 is None or not user.check_password(pwd):
# 验证失败,记录验证次数
try:
redis_store.incr("access_num_%s" % user_ip)
redis_store.expire("access_num_%s" % user_ip,
constants.LOGIN_ERROR_TIME)
except Exception as e:
current_app.logger.error(e)
return jsonify(error=RET.DATAERR, errmsg="用户名或密码输入有误")
# 如果验证成功,将登录状态记录在session中,并返回值
session["name"] = user.name
session["moblie"] = user.mobile
session["user_id"] = user.id
return jsonify(error=RET.OK, errmsg="登录成功")
def get_sms_code(moblie):
"""获取短信验证码"""
# 获取参数
image_code_id = request.args.get("image_code_id")
image_codes = request.args.get("image_codes")
# 校验参数
if not all([image_codes, image_code_id]):
# 表示参数不完整
return jsonify(error=response_code.RET.PWDERR, errmsg="参数不完整")
# 业务逻辑处理
# 从redis中取出真实的图片验证码
try:
real_image_code = redis_store.get("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(error=response_code.RET.DBERR, errmsg="redis数据库异常")
# 判断图片验证码是否过期
if real_image_code is None:
# 表示图片验证码没有或者过期
return jsonify(error=response_code.RET.NODATA, errmsg="图片验证码失效")
# 删除redis中的图片验证码，防止用户使用同一个图片验证码验证多次
try:
redis_store.delete("image_code_%s" % image_code_id)
except Exception as e:
current_app.logger(e)
# 与用户填写的值进行对比
'''
print("----------------------1---------------------------")
print("---%s----%s" % (real_image_code.lower(),image_codes.lower()))
print("----------------------2---------------------------")
----------------------1---------------------------
---b'zsyj'----zsyj 从url获取,比特类型 real_image_code.decode()
----------------------2---------------------------
'''
if real_image_code.decode().lower() != image_codes.lower():
# 表示用户填写错误
return jsonify(error=response_code.RET.DATAERR, errmsg="图片验证码错误")
# 判断对于这个手机号的操作，在60秒内有没有之前的记录，如果有，则认为用户操作频繁，不接受处理
try:
send_flag = redis_store.get("send_sms_code_%s" % moblie)
except Exception as e:
current_app.logger.error(e)
else:
if send_flag is not None:
# 表示在60秒内发送过记录
return jsonify(error=response_code.RET.REQERR, errmsg="请求过于频繁")
try:
user = User.query.filter_by(moblie=moblie).first()
except Exception as e:
current_app.logger.error(e)
else:
if user is not None:
# 表示手机号已存在
return jsonify(error=response_code.RET.DATAEXIST, errmsg="手机号已存在")
# 如果手机号不存在，则生成短信验证码 ,可以确保生成六位
sms_code = "%06d" % random.randint(0, 999999)
# 保存真实的短信验证码
try:
redis_store.setex("sms_code_%s" % moblie,
constants.SEND_SMS_CODE_OUTTIME, sms_code)
# 保存发送给这个手机号的记录，防止用户在60s内再次出发发送短信的操作
redis_store.setex("send_sms_code_%s" % moblie,
constants.SEND_SMS_CODE_OUTTIME, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(error=response_code.RET.DBERR, errmsg="保存短信验证码异常")
datas = sms_code, constants.SMS_CODE_REDIS_OUTTIME
'''
发送成功返回的值
{"statusCode":"000000","templateSMS":{"smsMessageSid":"b388c3051dc042
...: ec9e286ab30543db8e","dateCreated":"20210126143409"}}
'''
Send = {
"statusCode": "000000",
"templateSMS": {
"smsMessageSid": "a22692e1ea804c61b4830db8085d6186",
"dateCreated": "20210126154918"
}
}
Send = json.dumps(Send)
try:
# Send=send_msg(moblie,datas)
Send = json.loads(Send) #返回的值为json,需要将json格式转化为字典
print("----------------------1---------------------------")
print(Send)
print("----------------------2---------------------------")
except Exception as e:
current_app.logger.error(e)
if Send["statusCode"] == "000000":
return jsonify(error=response_code.RET.OK, errmsg="发送成功")
else:
return jsonify(error=response_code.RET.THIRDERR, errmsg="发送失败")
def register():
'''注册
请求参数:moblie,短信验证码,密码1 2
参数格式:json
'''
request_dict = request.get_json()
print("--------------1------------------------")
print(request_dict)
print(type(request_dict))
print("--------------1------------------------")
user_moblie = request_dict.get("mobile")
sms_codes = request_dict.get("sms_codes")
pwd1 = request_dict.get("password")
pwd2 = request_dict.get("password2")
if not all([user_moblie, sms_codes, pwd1, pwd2]):
return jsonify(error=RET.PARAMERR, errmsg="参数不完整")
# 判断手机号格式
if not re.match(r"1[3-9]\d{9}", user_moblie):
# 格式错误
return jsonify(error=RET.PARAMERR, errmsg="手机格式错误")
if pwd1 != pwd2:
return jsonify(error=RET.PARAMERR, errmsg="两次密码不一致")
# redis中取出短信验证码
try:
real_sms_codes = redis_store.get("sms_code_%s" % user_moblie)
except Exception as e:
current_app.logger.error(e)
return jsonify(error=RET.DBERR, errmsg="读取真实验证码异常")
# 并判断其有效期
if real_sms_codes is None:
return jsonify(error=RET.NODATA, errmsg="短信验证码失效")
# 删除redis中的短信验证码
try:
redis_store.delete("sms_codes_%s" % user_moblie)
except Exception as e:
current_app.logger.error(e)
# 判断用户的填写短信验证码正确性
if real_sms_codes.decode() != sms_codes:
return jsonify(error=RET.DATAERR, errmsg="短信验证码错误")
# 判断手机号是否注册过
# try:
# user=User.query.filter_by(moblie=user_moblie).first()
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(error=RET.DBERR, errmsg="数据库异常")
# else:
# if user is not None:
# # 表示手机号已存在
# return jsonify(error=RET.DATAEXIST,errmsg="手机号已存在")
# 将注册信息存入数据库
try:
users = User(name=user_moblie, mobile=user_moblie)
# users.generate_password_hash(pwd1) 第一种方法
users.password = pwd1 #设置密码
db.session.add(users)
db.session.commit()
except IntegrityError as e:
# 数据库操作错误回滚
db.session.rollback()
# 表示出现重复值,判断手机号是否注册过
current_app.logger.error(e)
return jsonify(error=RET.DATAEXIST, errmsg="手机号已存在")
except Exception as e:
current_app.logger.error(e)
return jsonify(error=RET.DBERR, errmsg="数据库异常")
# 保存登录状态
session["name"] = user_moblie
session["moblie"] = user_moblie
session["User_id"] = users.id
# 返回
return jsonify(error=RET.OK, errmsg="注册成功")