def pub_house():
"""发布房源：
0.登录校验 @login_required
1.g中获取user_id，前端获取房屋信息并校验数据
2.保存数据到数据库
3.返回响应
"""
# 1.前端获取房屋信息并校验数据
json_dict = request.json
area_id = json_dict.get('area_id')
capacity = json_dict.get('capacity')
title = json_dict.get('title')
price = json_dict.get('price')
facilities = json_dict.get('facility')
acreage = json_dict.get('acreage')
beds = json_dict.get('beds')
room_count = json_dict.get('room_count')
max_days = json_dict.get('max_days')
deposit = json_dict.get('deposit')
address = json_dict.get('address')
min_days = json_dict.get('min_days')
unit = json_dict.get('unit')
if not all(
[unit, min_days, max_days, address, deposit, room_count, beds, acreage, facilities, price, title, capacity,
area_id]):
return jsonify(re_code=RET.PARAMERR, msg='参数不完整')
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.debug(e)
return jsonify(re_code=RET.PARAMERR, msg='数据格式错误')
# 2.保存数据到数据库
house = House()
house.area_id = area_id
house.user_id = g.user_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
house.facilities = Facility.query.filter(Facility.id.in_(facilities)).all()
try:
db.session.add(house)
db.session.commit()
except Exception as e:
current_app.logger.debug(e)
db.session.rollback()
return jsonify(re_code=RET.DBERR, msg='新增房屋失败')
# 3.返回响应house_id
return jsonify(re_code=RET.OK, msg='发布房源成功', data={'house_id': house.id})
def post_house():
# 获取参数
response_dict = request.json
title = response_dict.get('title')
price = response_dict.get('price')
address = response_dict.get('address')
area_id = response_dict.get('area_id')
room_count = response_dict.get('room_count')
acreage = response_dict.get('acreage')
unit = response_dict.get('unit')
capacity = response_dict.get('capacity')
beds = response_dict.get('beds')
deposit = response_dict.get('deposit')
min_days = response_dict.get('min_days')
max_days = response_dict.get('max_days')
facility = response_dict.get('facility')
# 校验参数
if not all([
title, price, address, area_id, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
try:
price = float(price) * 100
deposit = float(deposit) * 100
except Exception as e:
return jsonify(errno=RET.PARAMERR, errmsg='金额类型不正确')
# 设置房屋
house = House()
house.user_id = g.user_id
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
if facility:
facilities = Facility.query.filter(Facility.id.in_(facility)).all()
house.facilities = facilities
try:
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='保存房屋信息失败')
return jsonify(errno=RET.OK, errmsg='OK', data={'house_id': house.id})
def save_house_info():
"""
发布新房源
1/确认用户身份id
2/获取参数,get_json()
3/判断数据的存在
4/获取详细的参数信息,指房屋的基本信息,不含配套设施title,price/area_id/address/unit/acreage/cacacity/beds/deposit/min_days/max_days/
5/检查参数的完整性
6/对价格参数进行转换,由元转成分
7/构造模型类对象,准备存储数据
8/判断配套设施的存在
9/需要对配套设施进行过滤查询,后端只会保存数据库中已经定义的配套设施信息
facilites = Facility.query.filter(Facility.id.in_(facility)).all()
house.facilities = facilities
10/保存数据到数据库中
11/返回结果,house.id,让后面上传房屋图片和房屋进行关联
:return:
"""
# 确认用户身份
user_id = g.user_id
# 获取参数post
house_data = request.get_json()
# 检查参数的存在
if not house_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 获取详细的房屋参数信息(基本信息,除配套设施外)
title = house_data.get('title') # 房屋标题
area_id = house_data.get('area_id') # 房屋城区
address = house_data.get('address') # 详细地址
price = house_data.get('price') # 房屋价格
room_count = house_data.get('room_count') # 房屋数目
acreage = house_data.get('acreage') # 房屋面积
unit = house_data.get('unit') # 房屋户型
capacity = house_data.get('capacity') # 人数上限
beds = house_data.get('beds') # 卧床配置
deposit = house_data.get('deposit') # 押金
min_days = house_data.get('min_days') # 最小入住天数
max_days = house_data.get('max_days') # 最大入住天数
# 检查参数的完整性
if not all([
title, area_id, address, price, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 对价格参数进行转换,由元转成分
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg='价格数据错误')
# 构造模型类对象,准备存储数据
house = House()
house.user_id = user_id
house.area_id = area_id
house.title = title
house.address = address
house.price = price
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 尝试获取房屋配套设施参数
facility = house_data.get('facility')
# 判断配套设施存在
if facility:
# 查询数据库,对房屋配套设施进行过滤查询,确保配套设施的编号在数据库中存在
try:
facilities = Facility.query.filter(Facility.id.in_(facility)).all()
# 保存房屋配套设施信息,配套设施的数据存在第三张表,关系引用在数据库中没有具体的字段
house.facilities = facilities
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询配套设施异常')
# 保存房屋数据到mysql数据库中
try:
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='保存房屋数据失败')
# 返回结果,house.id是用来后面实现上传房屋图片做准备
return jsonify(errno=RET.OK, errmsg='OK', data={'house_id': house.id})
def save_house_info():
u'''
参数
user_id
area_id
title
price
address
room_count
acreage
unit
capacity
beds
deposit
min_days
max_days
facilities: ['1', '2']
:return:
'''
# 获取数据
user_id = g.user_id
req_dict = request.get_json()
area_id = req_dict.get('area_id')
title = req_dict.get('title')
price = req_dict.get('price')
address = req_dict.get('address')
room_count = req_dict.get('room_count')
acreage = req_dict.get('acreage')
unit = req_dict.get('unit')
capacity = req_dict.get('capacity')
beds = req_dict.get('beds')
deposit = req_dict.get('deposit')
min_days = req_dict.get('min_days')
max_days = req_dict.get('max_days')
# 校验数据
if not all([area_id, title, price, address, room_count, acreage, unit, capacity, beds, deposit, min_days, max_days]):
return jsonify(errno=RET.PARAMERR, errmsg=u'参数不完整')
try:
price = int(float(price)*100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg=u'参数错误')
try:
area = Area.query.get(area_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'数据库错误')
if area is None:
return jsonify(errno=RET.NODATA, errmsg=u'城区不存在')
try:
room_count = int(room_count)
acreage = int(acreage)
capacity = int(capacity)
min_days = int(min_days)
max_days = int(max_days)
except Exception as e:
return jsonify(errno=RET.PARAMERR, errmsg=u'参数错误')
if room_count<0 or acreage<0 or capacity<0 or min_days<0 or max_days<0:
return jsonify(errno=RET.PARAMERR, errmsg=u'参数错误')
# 业务处理
house = House()
house.user_id = user_id,
house.area_id = area_id,
house.title = title,
house.price = price,
house.address = address,
house.room_count = room_count,
house.acreage = acreage,
house.unit = unit,
house.capacity = capacity,
house.beds = beds,
house.deposit = deposit,
house.min_days = min_days,
house.max_days = max_days
try:
db.session.add(house)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'数据库异常')
# 添加设备
facility_ids = req_dict.get('facility')
if facility_ids is not None:
try:
facilities = Facility.query.filter(Facility.id.in_(facility_ids)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'设备信息存储失败')
if facilities:
house.facilities = facilities
try:
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=u'发布房源失败')
# 返回响应
return jsonify(errno=RET.OK, errmsg=u'发布成功', data={'house_id': house.id})
def save_house_info():
"""
发布新房源
1.获取参数,user_id,房屋的基本信息和配套设施，get_json
2.校验参数的存在
3.获取房屋的详细信息
4.判断参数的完整性，不能包括facility字段
5.对价格进行处理，前端一般用户输入都是以元为单位,为了确保数据的准确性,
需要对价格转换,price = int ( float(price) * 100)
6.构造模型类对象，准备存储数据
7.尝试获取房屋的配套设施
8.校验获取的房屋配套设施是否存在
9.把房屋数据写入到数据库中
10.返回结果
:return:
"""
# 获取参数user_id
user_id = g.user_id
house_data = request.get_json()
# 判断参数是否存在
if not house_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 获取详细的房屋基本信息
title = house_data.get('title') # 房屋标题
price = house_data.get('price') # 房屋价格
area_id = house_data.get("area_id") # 房屋城区
address = house_data.get('address') # 房屋地址
room_count = house_data.get('room_count') # 房屋数目
acreage = house_data.get('acreage') # 房屋面积
unit = house_data.get('unit') # 房屋户型
capacity = house_data.get('capacity') # 适住人数
beds = house_data.get('beds') # 卧床配置
deposit = house_data.get('deposit') # 房屋押金
min_days = house_data.get('min_days') # 最小入住天数
max_days = house_data.get('max_days') # 最多入住天数
# 校验参数的完整性
if not all([
title, price, area_id, address, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 对价格进行处理
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="房屋价格数据错误")
# 构造模型类，存储数据
house = House()
house.user_id = user_id
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.unit = unit
house.capacity = capacity
house.acreage = acreage
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 尝试获取房屋的配套设施
facility = house_data.get('facility')
# 判断配套设施是否存在
if facility:
# 对配套设施进行检查，判断在数据库中是否存在
try:
facilities = Facility.query.filter(Facility.id.in_(facility)).all()
# 存储房屋的配套设施
house.facilities = facilities
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="配套设施查询异常")
# 存储房屋信息
try:
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="存储房屋信息失败")
# 返回结果 返回的house_id是给后面上传房屋图片,和房屋进行关联
return jsonify(errno=RET.OK, errmsg="OK", data={'house_id': house.id})
def save_new_house():
"""
1. 接收参数并且判空
2. 将参数的数据保存到新创建house模型
3. 保存house模型到数据库
前端发送过来的json数据
{
"title":"",
"price":"",
"area_id":"1",
"address":"",
"room_count":"",
"acreage":"",
"unit":"",
"capacity":"",
"beds":"",
"deposit":"",
"min_days":"",
"max_days":"",
"facility":["7","8"]
}
:return:
"""
# POST请求,获取参数
title = request.form.get('title')
price = request.form.get('price')
area_id = request.form.get('area_id')
address = request.form.get('address')
room_count = request.form.get('room_count')
acreage = request.form.get('acreage')
unit = request.form.get('unit')
capacity = request.form.get('capacity')
beds = request.form.get('beds')
deposit = request.form.get('deposit')
min_days = request.form.get('min_days')
max_days = request.form.get('max_days')
facility = request.form.get('facility')
user = g.ih_user_profile
# 非空判断
if not all([title, price, area_id, address, room_count, acreage, unit, capacity, beds, deposit, min_days, max_days,
facility]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
house = House()
# 标题
house.title = str(title)
# 价格
house.price = str(price)
house.area_id = int(area_id)
house.address = str(address)
house.room_count = int(room_count)
house.acreage = int(acreage)
house.unit = str(unit)
house.capacity = int(capacity)
house.beds = str(beds)
house.deposit = str(deposit)
house.min_days = int(min_days)
house.max_days = int(max_days)
house.facility = facility
house.user_id = g.ih_user_profile.id
house_id = g.ih_house_info.id
# 3.2 保存回数据库
try:
db.session.add(house)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
# 数据库回滚
db.session.rollback()
return jsonify(errno=RET.DBERR, errormsg="保存房源对象异常")
return jsonify(error=RET.OK, errmsg="发布房源成功", data={house_id})
def save_house_info():
"""添加房屋基本信息
前端传递的json信息：
{
"title": "",
"price": "",
"area_id": "",
"address": "",
"room_count": "", 出租房间数
"acreage: "", 房屋面积
"unit": "", 户型
"capacity": "", 适宜住宿人数
"beds": "", 卧床配置
"deposit":"", 押金
"min_day": "",
"max_day": "",
"facility": ["7", "8"] 配套设施
}
"""
# 1. 获取参数
house_data = request.get_json()
user_id = g.user_id
house_id = house_data.get("house_id")
title = house_data.get("title")
price = house_data.get("price")
area_id = house_data.get("area_id") # 城区号
address = house_data.get("address")
room_count = house_data.get("room_count") # 出租房间数
acreage = house_data.get("acreage") # 房屋面积
unit = house_data.get("unit") # 户型
capacity = house_data.get("capacity") # 适宜居住人数
beds = house_data.get("beds") # 卧床配置
deposit = house_data.get("deposit") # 押金
min_days = house_data.get("min_days")
max_days = house_data.get("max_days")
# 2. 校验参数
# 2.1 校验参数完整性
if not all([
title, price, area_id, address, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 2.2 校验价格格式是否正确
try:
price = int(float(price) * 100) # 因为数据库存储的是Integer
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 2.3 校验城区是否存在
try:
area = Area.query.get(area_id)
except Exception as e:
login_required.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据异常')
if area is None:
return jsonify(errno=RET.NODATA, errmsg='城区信息有误')
# 3. 业务逻辑
# 3.1 处理房屋信息
# 3.1.1 如果是新建房屋
if not house_id:
house = House(user_id=user_id,
area_id=area_id,
title=title,
price=price,
address=address,
room_count=room_count,
acreage=acreage,
unit=unit,
capacity=capacity,
beds=beds,
deposit=deposit,
min_days=min_days,
max_days=max_days)
# 3.1.2 如果是修改房屋信息
else:
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库异常1')
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 获取房屋图片信息
images = HouseImage.query.filter_by(house_id=house_id).all()
image_list = []
for image in images:
image_url = QINIU_URL_DOMAIN + image.url
image_list.append(image_url)
# 3.2 处理房屋设施信息
# 3.2.1 获取房屋设施列表
facility_ids = house_data.get("facility")
# 3.2.2 校验房屋设施（如果有数据，则保存数据）
if facility_ids:
try:
facilities = Facility.query.filter(
Facility.id.in_(facility_ids)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库异常2')
# 判断设施编号是否存在
if facilities:
# 如果是合法设施，保存到数据库
house.facilities = facilities
try:
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='保存数据失败')
# 4. 返回应答
# 4.1 如果是新建按房屋信息
if not house_id:
return jsonify(errno=RET.OK,
errmsg='创建成功',
data={"house_id": house.id})
# 4.2 如果是修改房屋信息
else:
return jsonify(errno=RET.OK,
errmsg='创建成功',
data={
"house_id": house.id,
"images": image_list
})
def pub_house():
"""发布新房源
0.判断用户是否登录 @login_required
1.接受所有参数,并判断是否缺少
2.校验参数：price / deposit， 需要用户传入数字
3.实例化房屋模型对象，并给属性赋值
4.保存到数据库
5.响应结果
"""
# 1.接受所有参数,并判断是否缺少
json_dict = request.json
title = json_dict.get('title')
price = json_dict.get('price')
address = json_dict.get('address')
area_id = json_dict.get('area_id')
room_count = json_dict.get('room_count')
acreage = json_dict.get('acreage')
unit = json_dict.get('unit')
capacity = json_dict.get('capacity')
beds = json_dict.get('beds')
deposit = json_dict.get('deposit')
min_days = json_dict.get('min_days')
max_days = json_dict.get('max_days')
if not all([
title, price, address, area_id, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 2.校验参数：price / deposit， 需要用户传入数字
# 提示：在开发中，对于像价格这样的浮点数，不要直接保存浮点数，因为有精度的问题，一般以分为单位
try:
price = int(float(price) * 100) # 0.1元 ==> 10分
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数格式错误')
# 3.实例化房屋模型对象，并给属性赋值
house = House()
house.user_id = g.user_id
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 处理房屋的设施 facilities = [2,4,6]
facilities = json_dict.get('facility')
# 查询出被选中的设施模型对象
house.facilities = Facility.query.filter(Facility.id.in_(facilities)).all()
# 4.保存到数据库
try:
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='发布新房源失败')
# 5.响应结果
return jsonify(errno=RET.OK, errmsg='发布新房源成功', data={'house_id': house.id})
def save_house_info():
"""
发布新房源
1/获取参数,user_id,房屋的基本信息和配套设施,get_json()
2/校验参数的存在
3/获取详细的房屋的基本参数信息:title,price,area_id,address,room_count,acreage,unit,capacity,beds,deposit,min_days,max_days
4/对参数的完整性进行检查,不能对facility进行处理
5/对价格进行处理,前端一般用户输入都是以元为单位,为了确保数据的准确性,需要对价格转换,price = int ( float(price) * 100)
6/构造模型类对象,准备存储房屋数据
7/尝试获取房屋配套设施
8/如果有配套设施,需要对配套设施进行校验,判断传入的配套设施是否在数据库中存储
9/把房屋数据写入数据库中
10/返回结果,需要返回house_id
:return:
"""
# 获取user_id
user_id = g.user_id
# 获取房屋的参数,post请求的参数
house_data = request.get_json()
# 检查参数的存在
if not house_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 获取房屋的详细的基本参数信息
title = house_data.get('title') # 房屋标题
price = house_data.get('price') # 房屋价格
area_id = house_data.get("area_id") # 房屋城区
address = house_data.get('address') # 房屋地址
room_count = house_data.get('room_count') # 房屋数目
acreage = house_data.get('acreage') # 房屋面积
unit = house_data.get('unit') # 房屋户型
capacity = house_data.get('capacity') # 适住人数
beds = house_data.get('beds') # 卧床配置
deposit = house_data.get('deposit') # 房屋押金
min_days = house_data.get('min_days') # 最小入住天数
max_days = house_data.get('max_days') # 最多入住天数
# 对房屋的基本设施的参数完整性进行检查
if not all([
title, price, area_id, address, unit, room_count, acreage,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 对房屋的价格进行处理,前端价格一般以元为单位,后端必须以分为单位
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg='房屋价格数据错误')
# 构造模型类对象,准备存储房屋数据
house = House()
house.user_id = user_id
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.unit = unit
house.capacity = capacity
house.acreage = acreage
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 尝试获取房屋配套设施
facility = house_data.get('facility')
# 判断配套设施是否存在
if facility:
# 对配套设施进行检查,确认配套设施在数据库中存在
try:
facilities = Facility.query.filter(Facility.id.in_(facility)).all()
# 存储房屋配套设施
house.facilities = facilities
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询配套设施异常')
# 存储房屋数据
try:
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='保存房屋信息失败')
# 返回结果,返回的house_id是给后面上传房屋图片,和房屋进行关联
return jsonify(errno=RET.OK, errmsg='OK', data={'house_id': house.id})
def save_new_house():
"""
房东发布房源信息
前端发送过来的json数据
{
"title":"",
"price":"",
"area_id":"1",
"address":"",
"room_count":"",
"acreage":"",
"unit":"",
"capacity":"",
"beds":"",
"deposit":"",
"min_days":"",
"max_days":"",
"facility":["7","8"]
}
"""
user_id = g.user_id # 用户编号
# 获取参数
house_data = request.get_json()
if house_data is None:
return jsonify(errno=RET.PARAMERR, errmsg="参数缺失")
title = house_data.get("title") # 房屋名称标题
price = house_data.get("price") # 房屋单价
area_id = house_data.get("area_id") # 房屋所属城区的编号
address = house_data.get("address") # 房屋地址
room_count = house_data.get("room_count") # 房屋包含的房间数目
acreage = house_data.get("acreage") # 房屋面积
unit = house_data.get("unit") # 房屋布局（几室几厅)
capacity = house_data.get("capacity") # 房屋容纳人数
beds = house_data.get("beds") # 房屋卧床数目
deposit = house_data.get("deposit") # 押金
min_days = house_data.get("min_days") # 最小入住天数
max_days = house_data.get("max_days") # 最大入住天数
# 校验传入数据
if not all((title, price, area_id, address, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days)):
return jsonify(errno=RET.PARAMERR, errmsg="参数缺失")
# 前端传过来的单价和押金是以元为单位，转换为分
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 保存房屋基本信息数据到数据库
house = House()
house.user_id = user_id
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 处理房屋的设施编号
facility = house_data.get("facility")
if facility:
# 过滤用户发送的设施信息，查找出真实存在的设施，过滤掉错误的设施编号
facilities = Facility.query.filter(Facility.id.in_(facility)).all()
house.facilities = facilities
try:
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="保存房屋数据失败")
return jsonify(errno=RET.OK, errmsg="OK", data={"house_id": house.id})
def set_house_info():
"""
设置房屋信息
1. 获取必选参数
2. 校验必选参数
3. 获取方位配套设施参数
4. 校验配套设施是否为有效数据，保留有效数据，去掉无效数据
5. 构建模型对象，保存到数据库
6. 保存房屋设施
7. 保存成功后，返回数据
:return:
"""
# 1. 获取房屋信息参数
house_data = request.get_json()
user_id = g.user_id
title = house_data.get('title')
price = house_data.get('price')
area_id = house_data.get('area_id')
address = house_data.get('address')
room_count = house_data.get('room_count')
acreage = house_data.get('acreage')
unit = house_data.get('unit')
capacity = house_data.get('capacity')
beds = house_data.get('beds')
deposit = house_data.get('deposit')
min_days = house_data.get('min_days')
max_days = house_data.get('max_days')
# 2. 校验所有参数不为空
if not all([title, price, area_id, address, room_count, acreage, unit, capacity, beds, deposit, min_days, max_days]):
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 3. 处理price和depoist的金钱信息，将“元”转化为“分”
try:
price = int(float(price)*100)
deposit = int(float(deposit)*100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg='价格或押金数据错误')
# 6. 构造模型对象
house = House()
house.user_id = user_id
house.area_id = area_id # 归属地的区域编号
house.title = title # 标题
house.price = price # 单价，单位：分
house.address = address # 地址
house.room_count = room_count # 房间数目
house.acreage = acreage # 房屋面积
house.unit = unit # 房屋单元， 如几室几厅
house.capacity = capacity # 房屋容纳的人数
house.beds = beds # 房屋床铺的配置
house.deposit = deposit # 房屋押金
house.min_days = min_days # 最少入住天数
house.max_days = max_days # 最多入住天数，0表示不限制
# 4. 获取房屋配额设施
facility = house_data.get('facility')
print facility
# 5. 验证房屋数据是否有效，去掉无效数据
if facility:
try:
facilities = Facility.query.filter(Facility.id.in_(facility)).all()
house.facilities = facilities
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg='获取用户设施失败')
# 7. 向数据库中保存模型对象
try:
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='保存数据异常')
return jsonify(errno=RET.OK, errmsg='OK', data={'house_id': house.id})
def save_house_info():
"""
保存房屋的基本信息
:param: 前端发来的数据
{
"title":"",
"price":"",
"area_id":"1",
"address":"",
"room_count":"",
"acreage":"",
"unit":"",
"capacity":"",
"beds":"",
"deposit":"",
"min_days":"",
"max_days":"",
"facility":["7","8"]
}
:return: 'ok'
"""
# 获取数据
user_id = g.user_id
house_data = request.get_json()
title = house_data.get("title") # 房屋名称标题
price = house_data.get("price") # 房屋单价
area_id = house_data.get("area_id") # 房屋所属城区的id
address = house_data.get("address") # 房屋地址
room_count = house_data.get("room_count") # 房屋包含的房间数目
acreage = house_data.get("acreage") # 房屋面积
unit = house_data.get("unit") # 房屋布局（几室几厅)
capacity = house_data.get("capacity") # 房屋容纳人数
beds = house_data.get("beds") # 房屋卧床数目
deposit = house_data.get("deposit") # 押金
min_days = house_data.get("min_days") # 最小入住天数
max_days = house_data.get("max_days") # 最大入住天数
# 校验参数
if not all([
title, price, area_id, address, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 判断金额是否正确
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 判断城区id是否存在
try:
area = Area.query.get(area_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库异常')
if area is None:
return jsonify(errno=RET.NODATA, errmsg='城区信息有误')
# 保存房屋信息
house = House()
house.user_id = user_id
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 处理房屋的设施信息
facility_ids = house_data.get("facility")
# 如果用户勾选了设施信息，再保存数据库
if facility_ids:
try:
facilities = Facility.query.filter(
Facility.id.in_(facility_ids)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库异常')
if facilities:
# 表示有合法的设施数据，需要保存
house.facilities = facilities
try:
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='保存数据失败')
# 保存数据成功
return jsonify(errno=RET.OK, errmsg='ok', data={'house_id': house.id})
def save_new_house():
# 获取上传的参数
# 判断参数是否为空
# 初始化House的对象
# 返回结果
# 前端发送过来的json数据
'''
{
"title": "",
"price": "",
"area_id": "1",
"address": "",
"room_count": "",
"acreage": "",
"unit": "",
"capacity": "",
"beds": "",
"deposit": "",
"min_days": "",
"max_days": "",
"facility": ["7", "8"]
}
'''
# 获取上传的参数
user_id = g.user_id
json_dict = request.json
title = json_dict.get("title")
price = json_dict.get("price")
area_id = json_dict.get("area_id")
address = json_dict.get("address")
unit = json_dict.get("unit")
room_count = json_dict.get("room_count")
acreage = json_dict.get("acreage")
capacity = json_dict.get("capacity")
beds = json_dict.get("beds")
deposit = json_dict.get("deposit")
min_days = json_dict.get("min_days")
max_days = json_dict.get("max_days")
# 判断参数是否为空
if not all([title,price,area_id,address,unit,room_count,acreage,capacity,beds,deposit,min_days,max_days]):
return json_dict(erron=RET.PARAMERR,errmsg="参数不足")
# 判断传入的价钱是否是数字，然后将其转为一分为单位的价格
try:
price = int(float(price)*100)
deposit = int(float(deposit)*100)
except Exception as e:
current_app.logger.error(e)
return jsonify(erron=RET.PARAMERR,errmsg="参数不足")
# 初始化house对象
house = House()
house.user_id = user_id
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 设置房屋设施
facilities = json_dict.get("facility")
if facilities:
house.facilities = Facility.query.filter(Facility.id.in_(facilities)).all()
# 进行数据保存
try:
db.session.add(house)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(erron=RET.DBERR,errmsg="添加数据失败")
return jsonify(erron=RET.OK,errmsg="OK",data={"house_id":house.id})
def public_house():
user_id = int(g.user_id)
try:
user = User.query.get(user_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据查询错误')
# 如果用户不存在
if user is None:
return jsonify(errno=RET.USERERR, errmsg='用户不存在')
# if request.method == 'GET':
# pass
house_dict = request.json
if not house_dict:
return jsonify(errno=RET.PARAMERR, errmsg='请输入参数')
title = house_dict.get('title')
price = house_dict.get('price')
address = house_dict.get('address')
area_id = house_dict.get('area_id')
room_count = house_dict.get('room_count')
acreage = house_dict.get('acreage')
unit = house_dict.get('unit')
capacity = house_dict.get('capacity')
beds = house_dict.get('beds')
deposit = house_dict.get('deposit')
min_days = house_dict.get('min_days')
max_days = house_dict.get('max_days')
if not all([
title, price, address, area_id, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='传入参数错误')
house = House()
house.user_id = user_id
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
facility = house_dict.get('facility')
if facility:
facilities = Facility.query.filter(Facility.id.in_(facility)).all()
house.facilities = facilities
try:
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='保存房屋信息失败')
return jsonify(errno=RET.OK, errmsg='OK', house_id=house.id)
def save_house_info():
#发布新房源
#获取user_id
user_id = g.user_id
#获取post请求的json数据
house_data = request.get_json()
#判断获取结果
if not house_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
#获取详细参数 -- 房屋基本信息
title = house_data.get('title') # 房屋标题
area_id = house_data.get('area_id') # 房屋城区
address = house_data.get('address') # 详细地址
price = house_data.get('price') # 房屋价格
room_count = house_data.get('room_count') # 房屋数目
acreage = house_data.get('acreage') # 房屋面积
unit = house_data.get('unit') # 房屋户型
capacity = house_data.get('capacity') # 人数上限
beds = house_data.get('beds') # 卧床配置
deposit = house_data.get('deposit') # 押金
min_days = house_data.get('min_days') # 最小入住天数
max_days = house_data.get('max_days') # 最大入住天数
#检验详细参数
if not all([
title, area_id, address, price, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
#把价格和押金的单位由元转成分
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg='价格数据错误')
#构建模型类，准备存储房屋信息
house = House()
house.user_id = user_id
house.area_id = area_id
house.title = title
house.address = address
house.price = price
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
#尝试获取配套设施参数
facility = house_data.get('facility')
#判断配套设施存在
if facility:
#查询数据库,过滤出数据库设置的配套设施并且添加到模型类
try:
facilities = Facility.query.filter(Facility.id.in_(facility)).all()
house.facilities = facilities
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询配套设施异常')
#保存数据到数据库
try:
db.session.add(house)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, ermsg='保存房屋信息失败')
#返回结果
return jsonify(errno=RET.OK, errmsg='OK', data={'house_id': house.id})
def set_house_info():
"""
1.获取用户编号
2.获取房屋的基本信息, 设施信息
3.校验参数
4.房屋价格, 押金的整数处理
5.创建房屋对象
6.将房屋的基本信息设置到房屋对象中
7.通过设施信息,取出设置列表,设置到房屋对象中
8.设置房屋的主人
9.更新内容数据库
10.返回,携带房屋编号
:return:
"""
# 1.获取用户编号
user_id = g.user_id
# 2.获取房屋的基本信息, 设施信息
dict_data = request.json
title = dict_data.get("title")
price = dict_data.get("price")
area_id = dict_data.get("area_id")
address = dict_data.get("address")
room_count = dict_data.get("room_count")
acreage = dict_data.get("acreage")
unit = dict_data.get("unit")
beds = dict_data.get("beds")
deposit = dict_data.get("deposit")
min_days = dict_data.get("min_days")
max_days = dict_data.get("max_days")
facilities = dict_data.get("facility")
# 3.校验参数
if not all([
title, price, area_id, address, room_count, acreage, unit, beds,
deposit, min_days, max_days
]):
return jsonify(errno=RET.DATAERR, errmsg="参数不完整")
# 4.房屋价格, 押金的整数处理
# 由于在使用支付宝支付的时候,最小单位是分, 所以保存在数据库中的价格,单位是分
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="单价或者押金格式不正确")
# 5.创建房屋对象
house = House()
# 6.将房屋的基本信息设置到房屋对象中
house.title = title
house.price = price
house.area_id = area_id
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 7.通过设施信息,取出设施列表,设置到房屋对象中
facilities = Facility.query.filter(Facility.id.in_(facilities)).all()
house.facilities = facilities
# 8.设置房屋的主人
house.user_id = user_id
# 9.更新内容数据库
try:
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="数据保存异常")
# 10.返回,携带房屋编号
return jsonify(errno=RET.OK, errmsg="房屋发布成功", data={"house_id": house.id})
def send_house_basic_info():
title = request.json.get("title")
price = request.json.get("price")
area_id = request.json.get("area_id")
address = request.json.get("address")
room_count = request.json.get("room_count")
acreage = request.json.get("acreage")
unit = request.json.get("unit")
capacity = request.json.get("capacity")
beds = request.json.get("beds")
deposit = request.json.get("deposit")
min_days = request.json.get("min_days")
max_days = request.json.get("max_days")
facilities = request.json.get("facility") # 格式:[1,
if not all([
title, price, area_id, address, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
house = House()
house.title = title
price = request.json.get("price")
area_id = request.json.get("area_id")
address = request.json.get("address")
room_count = request.json.get("room_count")
acreage = request.json.get("acreage")
unit = request.json.get("unit")
capacity = request.json.get("capacity")
beds = request.json.get("beds")
deposit = request.json.get("deposit")
min_days = request.json.get("min_days")
max_days = request.json.get("max_days")
facilities = request.json.get("facility") # 格式:[1,2,3,4]
# 2.校验参数,基本信息校验
if not all([
title, price, area_id, address, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 3.创建房屋对象
house = House()
# 4.设置房屋对象的数据
house.title = title
house.price = price
house.area_id = area_id
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
facility_list = Facility.query.filter(Facility.id in (facilities)).all()
house.facilities = facility_list
house.user_id = g.user_id
try:
db.session.add(house)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存异常")
# 7.返回
return jsonify(errno=RET.OK, errmsg="发布成功", data={"house_id": house.id})
def save_house_info():
"""
保存房屋信息
1/获取用户信息,user_id
2/获取参数,post请求的data数据get_json()
3/校验参数存在
4/获取详细的房屋基本配置参数信息(除房屋配套设施外的参数)
5/校验参数的完整性
6/对价格参数进行转换,由元转成分
7/构造模型类对象,准备保存房屋数据
8/尝试获取配套设施参数信息
9/如果有配套设施,对设施编号进行过滤查询,确保前端传入的配套设施存在
facility
Facility.query.filter(Facility.id.in_(facility)).all()
10/提交数据到数据库中,如果发生异常需要进行回滚
11/返回结果,需要返回house.id
:return:
"""
# 获取用户身份信息
user_id = g.user_id
# 获取房屋的参数信息
house_data = request.get_json()
# 校验参数的存在
if not house_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 获取详细的房屋参数信息,房屋的基本信息
title = house_data.get('title') # 房屋名称
price = house_data.get('price') # 房屋价格
area_id = house_data.get('area_id') # 房屋区域
address = house_data.get('address') # 详细地址
room_count = house_data.get('room_count') # 房屋数目
acreage = house_data.get('acreage') # 房屋面积
unit = house_data.get('unit') # 房屋户型
capacity = house_data.get('capacity') # 适住人数
beds = house_data.get('beds') # 卧床配置
deposit = house_data.get('deposit') # 房屋押金
min_days = house_data.get('min_days') # 最少入住天数
max_days = house_data.get('max_days') # 最多入住天数
# 校验参数的完整性
if not all([
title, price, area_id, address, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 对金额进行单位转换,前端一般使用元为单位,数据库中存储以分未单位
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg='价格转换错误')
# 构造模型类对象,准备存储房屋数据
house = House()
house.user_id = user_id
house.title = title
house.price = price
house.area_id = area_id
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 尝试获取配套设施信息
facility = house_data.get('facility')
# 如果存在配套设施,需要对配套设施的编号进行过滤,确认配套设施存在
if facility:
try:
facilities = Facility.query.filter(Facility.id.in_(facility)).all()
# 保存配套设施
house.facilities = facilities
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询配套设施失败')
# 提交数据到数据库中
try:
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='保存房屋数据失败')
# 返回结果house.id
return jsonify(errno=RET.OK, errmsg='OK', data={'house_id': house.id})
def save_house_info():
'''
保存房屋信息
1 获取参数 user_id = g.user_id 房屋所属用户
2 获取参数 post请求的房屋信息 get_json()
3 校验参数存在
4 获取详细的参数信息
5 校验参数完整性
6 对价格信息进行处理
7 保存房屋基本信息 house = House() house,title = title
8 尝试获取配套设施信息,如果存在 判断设施编号和数据源中存储的一致
9 保存房屋设施数据
10 提交数据到数据库
11 返回结果 data:{'house_id':house.id}
'''
# 获取用户id
user_id = g.user_id
# 获取post请求的房屋基本信息
house_data = request.get_json()
# 校验参数
if not house_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 获取纤细参数
title = house_data.get('title') # 房屋标题
price = house_data.get('price') # 房屋价格
area_id = house_data.get('area_id') # 房屋区域
address = house_data.get('address') # 房屋地址
room_count = house_data.get('room_count') # 房屋数目
acreage = house_data.get('acreage') # 房屋面积
unit = house_data.get('unit') # 房屋户型
capacity = house_data.get('capacity') # 适住人数
beds = house_data.get('beds') # 床位设施
deposit = house_data.get('deposit') # 房屋押金
min_days = house_data.get('min_days') # 最少入住天数
max_days = house_data.get('max_days') # 最多入住天数
# 校验参数完整性
if not all([
title, price, area_id, address, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 对价格信息进行转换
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="房屋价格信息异常")
# 构造模型对象 存储数据
house = House()
house.user_id = user_id
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 尝试获取房屋配套设施信息
facility = house_data.get('facility')
# 配套设施如果存在 需要过滤配套设施对应到数据库中真实存在
if facility:
try:
# 过滤房屋设施编号 如果该房屋设施编号不存在 需要过滤操作
facilities = Facility.query.filter(Facility.id.in_(facility).all())
# 保存查询结果
house.facilities = facilities
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询房屋配套设施异常")
# 保存房屋数据,提交数据到数据库中
try:
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="保存房屋信息失败")
# 返回结果
return jsonify(errno=RET.OK, errmsg="OK", data={"house_id": house.id})
def save_new_house():
"""
1. 接收参数并且判空
2. 将参数的数据保存到新创建house模型
3. 保存house模型到数据库
前端发送过来的json数据
{
"title":"",
"price":"",
"area_id":"1",
"address":"",
"room_count":"",
"acreage":"",
"unit":"",
"capacity":"",
"beds":"",
"deposit":"",
"min_days":"",
"max_days":"",
"facility":["7","8"]
}
:return:
"""
user_id = g.user_id
house_data = request.get_json()
title = house_data.get("title")
price = house_data.get("price")
area_id = house_data.get("area_id")
address = house_data.get("address")
room_count = house_data.get("room_count")
acreage = house_data.get("acreage")
unit = house_data.get("unit")
capacity = house_data.get("capacity")
beds = house_data.get("beds")
deposit = house_data.get("deposit")
min_days = house_data.get("min_days")
max_days = house_data.get("max_days")
if not all([
title, price, area_id, address, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
# 判断房屋单价和押金是否为正确参数
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 查询城区id是否存在
try:
area = Area.query.get(area_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="城区查询异常")
if area is None:
return jsonify(errno=RET.NODATA, errmsg="参数有误")
house = House()
house.user_id = user_id
house.title = title
house.price = price
house.area_id = area_id
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
facility_id = house_data.get("facility")
facilities = None
if facility_id:
try:
# 如果facility_id在Facility中, 才查询出来
facilities = Facility.query.filter(
Facility.id.in_(facility_id)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="参数有误")
if facilities:
house.facilities = facilities
try:
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="保存数据异常")
return jsonify(errno=RET.OK, errmsg="OK", data={"house_id": house.id})
def save_house_info():
"""
发布新房源
1/确认用户身份id
2/获取参数,get_json()
3/判断数据的存在
4/获取详细的参数信息,指房屋的基本信息,不含配套设施title,price/area_id/address/unit/acreage/cacacity/beds/deposit/min_days/max_days/
5/检查参数的完整性
6/对价格参数进行转换,由元转成分
7/构造模型类对象,准备存储数据
8/判断配套设施的存在
9/需要对配套设施进行过滤查询,后端只会保存数据库中已经定义的配套设施信息
facilites = Facility.query.filter(Facility.id.in_(facility)).all()
house.facilities = facilities
10/保存数据到数据库中
11/返回结果,house.id,让后面上传房屋图片和房屋进行关联
:return:
"""
# 获取user_id
user_id = g.user_id
# 获取post参数
house_data = request.get_json()
# 检验参数的存在
if not house_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 获取详细参数信息
title = house_data.get("title") # 房屋标题
area_id = house_data.get("area_id") # 房屋城区
address = house_data.get("address") # 详细地址
price = house_data.get("price") # 房屋价格
room_count = house_data.get("room_count") # 房屋数目
acreage = house_data.get("acreage") # 房屋面积
unit = house_data.get("unit") # 房屋户型
capacity = house_data.get("capacity") # 适住人数
beds = house_data.get("beds") # 卧床配置
deposit = house_data.get("deposit") # 押金
min_days = house_data.get("min_days") # 最小入住天数
max_days = house_data.get("max_days") # 最大入住天数
# 检验参数完整性
if not all([
title, area_id, address, price, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 对价格参数进行转换
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="价格数据错误")
# 构造模型类对象
house = House()
house.user_id = user_id
house.area_id = area_id
house.title = title
house.address = address
house.price = price
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 获取房屋配套设施参数信息
facility = house_data.get("facility")
# 判断配套设施的存在
if facility:
# 查询数据库，对房屋配套设施进行过滤查询，确保配套设施的编号在数据库中存在
try:
facilities = Facility.quert.filter(Facility.id.in_(facility)).all()
# 保存房屋配套设施信息，配套设施的数据存在第三张表，关系引用在数据库中没有具体字段
house.facilities = facilities
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询配套设施异常")
# 保存房屋数据到mysql数据库
try:
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="保存房屋数据失败")
# 返回结果，house.id是用来后面实现上传房屋图片做准备（前段获取数据）
return jsonify(errno=RET.OK, errmsg="OK", data={"house_id": house.id})
def save_new_house():
"""
1. 接收参数并且判空
2. 将参数的数据保存到新创建house模型
3. 保存house模型到数据库
前端发送过来的json数据
{
"title":"",
"price":"",
"area_id":"1",
"address":"",
"room_count":"",
"acreage":"",
"unit":"",
"capacity":"",
"beds":"",
"deposit":"",
"min_days":"",
"max_days":"",
"facility":["7","8"]
}
:return:
"""
# 1. 取到参数
user_id = g.user_id
json_dict = request.json
title = json_dict.get('title')
price = json_dict.get('price')
address = json_dict.get('address')
area_id = json_dict.get('area_id')
room_count = json_dict.get('room_count')
acreage = json_dict.get('acreage')
unit = json_dict.get('unit')
capacity = json_dict.get('capacity')
beds = json_dict.get('beds')
deposit = json_dict.get('deposit')
min_days = json_dict.get('min_days')
max_days = json_dict.get('max_days')
# 1.1 判断是否都有值
if not all([
title, price, address, area_id, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
# 1.2 校验参数格式是否正确
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
house = House()
house.user_id = user_id
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 获取到当前房屋的设施列表数组
facilities = json_dict.get("facility")
if facilities:
house.facilities = Facility.query.filter(
Facility.id.in_(facilities)).all()
# 3.保存house模型到数据库
try:
db.session.add(house)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据保存错误")
return jsonify(errno=RET.OK, errmsg="ok", data={"house_id": house.id})
def save_house_info():
"""
发布新房源
1. 获取参数, g.user_id, 房屋的基本信息, 配套设施
2. 判断json数据包是否存在
3. 获取详细参数信息
4. 判断房屋基本信息的完整性
5. 价格参数: 前端价格以元为单位, 后端数据以分为单位保存
6. 构造模型类对象, 保存房屋数据
7. 判断配套设施参数, 如有保存, 否则不存
8. 提交数据, 返回结果{房屋id}
:return:
"""
# 获取json数据包
json_data = request.get_json()
if not json_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 提取房屋参数信息
title = json_data.get('title')
area_id = json_data.get('area_id')
price = json_data.get('price')
address = json_data.get('address')
room_count = json_data.get('room_count')
acreage = json_data.get('acreage')
unit = json_data.get('unit')
capacity = json_data.get('capacity')
beds = json_data.get('beds')
deposit = json_data.get('deposit')
min_days = json_data.get('min_days')
max_days = json_data.get('max_days')
if not all([title, price, address, area_id, room_count, acreage, unit, capacity, beds, deposit, min_days, max_days]):
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 对价格参数单位进行转换
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg='金额格式错误')
# 保存房屋信息
house = House()
house.user_id = g.user_id
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 尝试获取房屋配套设施参数
facility = json_data.get('facility')
if facility:
# 对胚胎设施进行校验, 该设施在数据库有存储
try:
facilities = Facility.query.filter(Facility.id.in_(facility)).all()
house.facilities = facilities
except Exception as e:
current_app.logger.error(e)
try:
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='数据保存异常')
else:
return jsonify(errno=RET.OK, errmsg='OK', data={'house_id': house.id})
def pub_house():
# 1.判断登陆状态
# 2.获取参数 --13个
# 3.对数据进行校验 --完整性校验 --价钱有效性校验
# 4.保存数据对象属性
# 5.提交数据操作
# 6.响应
# 2.获取参数 --13个
json_dict = request.json
title = json_dict.get('title') # 标题
price = json_dict.get('price') # 价钱--分
address = json_dict.get('address')
area_id = json_dict.get('area_id')
room_count = json_dict.get('room_count')
acreage = json_dict.get('acreage') # 房屋面积
unit = json_dict.get('unit')
capacity = json_dict.get('capacity')
beds = json_dict.get('beds')
deposit = json_dict.get('deposit') # 房屋押金
min_days = json_dict.get('min_days')
max_days = json_dict.get('max_days')
# 配置物品有可能都不配，所以不放在all（）里面判断
facilities = json_dict.get('facility') # 配置的物品复选框列表类型传入 【2,4,6】
# ---数据完整性判断---
if not all([
title, price, address, area_id, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg=u'信息填写不完整')
# ---1.对于价钱这类存在浮点数，或者数字的数据，需要进行校验数据有效性校验，防止传入字符等---
# ---2.对于浮点数的数据存储，需要将浮点数转化为整数进行存储。如价钱，使用价钱×100.以分为单位，进行整数存储---
# ---3.浮点数存在精度问题，所以输出存数不使用浮点数存储---
try: # 先试转成浮点数，可以转说明不是字符串
price = int(float(price) * 100)
acreage = int(float(acreage) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg=u'数据格式不正确')
# 4.保存数据对象属性
house = House()
house.user_id = g.user_id
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 如果发布时，有选择设备，就把选择的设备添加到house.facilities 属性保存
if facilities:
try:
house.facilities = Facility.query.filter(
Facility.id.in_(facilities)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'数据查询失败')
# 4.保存到数据库
try:
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='发布新房源失败')
# 5.响应结果 传入house_id 是为了埋在html，给别的接口获取数据
return jsonify(errno=RET.OK, errmsg='发布新房源成功', data={'house_id': house.id})
def save_house_info():
"""
保存发布房屋的信息：
1. 接收参数并进行参数校验
2. 创建House对象并保存房屋的基本信息
3. 将房屋信息存进数据库
4. 返回应答，发布房屋信息成功
:return:
"""
# 1. 接收参数并进行参数校验
req_dict = request.json
title = req_dict.get('title')
price = req_dict.get('price')
address = req_dict.get('address')
area_id = req_dict.get('area_id')
room_count = req_dict.get('room_count')
acreage = req_dict.get('acreage')
unit = req_dict.get('unit')
capacity = req_dict.get('capacity')
beds = req_dict.get('beds')
deposit = req_dict.get('deposit')
min_days = req_dict.get('min_days')
max_days = req_dict.get('max_days')
if not all([
title, price, address, area_id, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
try:
# 数据库中房屋单价和押金 以 分 为单位保存
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 2. 创建House对象并保存房屋的基本信息
house = House()
house.user_id = g.user_id
house.area_id = area_id
house.title = title
house.price = price
house.address = address
house.room_count = room_count
house.acreage = acreage
house.unit = unit
house.capacity = capacity
house.beds = beds
house.deposit = deposit
house.min_days = min_days
house.max_days = max_days
# 获取房屋的设施信息
facility = req_dict.get("facility")
if facility:
# 获取房屋设施的信息
try:
facilities = Facility.query.filter(Facility.id.in_(facility)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取房屋设施失败")
# 设置房屋设施信息
house.facilities = facilities
# 3. 将房屋信息存进数据库
try:
db.session.add(house)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存房屋信息失败")
# 4. 返回应答，发布房屋信息成功
return jsonify(errno=RET.OK, errmsg="发布房屋信息成功", data=house.to_basic_dict())
def set_house_info():
"""
发布新房源
1 获取参数,user_id,房屋的基本信息和配套设施(get_json())
2 校验参数的存在
3 获取详细的房屋的基本参数
4 对参数的完整性进行检查,不能对facility进行处理
5 对价格进行处理, 前端一般用户输入都是以元为单位,为了确保数据的准确性,需要对价格进行转换
price=int(float(price)*100)
6 构造模型类对象,准备存储房屋数据
7 尝试获取房屋配套设施
8 如果有配套设施,需要对配套设施进行校验,判断传入的配套设施是否在数据库中存储
9 把房屋数据写入数据库中
10 返回结果,需要返回house_id
:return:
"""
# 获取user_id
user_id = g.user_id
# 获取房屋参数,获取json数据
house_data = request.get_json()
# 检查参数的存在
if not house_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 获取房屋的详细基本信息
title = house_data.get('title') # 房屋标题
price = house_data.get('price') # 房屋价格
area_id = house_data.get('area_id') # 房屋所属城区id
address = house_data.get('address') # 房屋地址
room_count = house_data.get('room_count') # 房间数目
acreage = house_data.get('acreage') # 房屋面积
unit = house_data.get('unit') # 户型描述
capacity = house_data.get('capacity') # 适住人数
beds = house_data.get('beds') # 卧床配置
deposit = house_data.get('deposit') # 房屋押金
min_days = house_data.get('min_days') # 最小入住天数
max_days = house_data.get('max_days') # 最大入住天数
# 对房屋的基本信息进行完整性校验
if not all([title, price, area_id, address, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days]):
return jsonify(errno=RET.PARAMERR, errmsg="房屋参数不完整")
# 对房屋价格进行处理,前端价格一般是以元为单位,后端必须以分为单位
try:
price = int(float(price)*100)
deposit = int(float(deposit)*100)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg='房屋价格数据错误')
# 如果参数无误,构造模型类对象,准备存储房屋数据
house = House()
house.user_id = user_id
house.area_id = area_id
house.address = address
house.title = title
house.price = price
house.deposit = deposit
house.room_count = room_count
house.beds = beds
house.acreage = acreage
house.capacity = capacity
house.unit = unit
house.min_days = min_days
house.max_days = max_days
# 尝试获取房屋配套设施
facility = house_data.get('facility')
# 判断配套设施是否存在
if facility:
# 对房屋设施进行检查,确保配套设施在数据库中存在
try:
facilities = Facility.query.filter(Facility.id.in_(facility)).all()
# 存储房屋的配套设施
house.facilities = facilities
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询配套设施异常")
# 存储房屋数据
try:
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="保存房屋信息失败")
# 返回结果,返回的house_id是给后面上传房屋图片,和房屋进行关联
return jsonify(errno=0, errmsg="OK", data={'house_id': house.id})
