def save_house_info():
"""保存房屋的基本信息
前端发送过来的json数据
{
"title":"",
"price":"",
"area_id":"1",
"address":"",
"room_count":"",
"acreage":"",
"unit":"",
"capacity":"",
"beds":"",
"deposit":"",
"min_days":"",
"max_days":"",
"facility":["7","8"]
}
"""
# 一. 获取参数
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.DATAERR, errmsg="参数有误")
# 三. 保存信息
# 1. 创建房屋对象
user_id = g.user_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
)
# 2. 处理房屋的设施信息
facility_id_list = house_data.get("facility")
if facility_id_list:
# 表示用户勾选了房屋设施
# 过滤用户传送的不合理的设施id
# select * from facility where id in (facility_id_list)
try:
facility_list = Facility.query.filter(Facility.id.in_(facility_id_list)).all()
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库异常")
# 为房屋添加设施信息
if facility_list:
house.facilities = facility_list
# 3. 保存数据库
try:
db.session.add(house)
db.session.commit()
except Exception as e:
logging.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="保存数据失败")
# 四. 返回
return jsonify(errno=RET.OK, errmsg="保存成功", data={"house_id": house.id})
def save_house_info():
"""保存房屋的基本信息
前端发送过来的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()
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(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)
# 处理房屋的设施信息
facility_ids = house_data.get("facility")
# 如果用户勾选了设施信息，再保存数据库
if facility_ids:
# ["7","8"]
try:
# select * from ih_facility_info where id in []
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_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 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():
"""
保存要发布的房源的信息
:param:{
title
price
area_id
address
room_count
acreage
unit
capacity
beds
deposit
min_days
max_days
facility
}
:return:
"""
house_dict = request.get_json()
title = house_dict.get("title") # 名称标题
price = house_dict.get("price") # 单价
area_id = house_dict.get("area_id") # 所属城区
address = house_dict.get("address") # 详细地址
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") # 最大入住天数
# facility = house_dict.get("facility") # 房屋名称标题
# 校验参数
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 not area:
return jsonify(errno=RET.NODATA, errmsg="城区信息有误")
# 保存房屋信息
house = House(
user_id=g.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,
)
# 处理房屋设施信息
facilities = house_dict.get("facility")
if facilities:
try:
facilities_list = Facility.query.filter(
Facility.id.in_(facilities)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据库异常")
if facilities_list:
# 保存设施信息
house.facilities = facilities_list
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="保存成功", data={"house_id": house.id})
def save_house_info():
"""保存房屋的基本信息：发布
前端发送过来的json数据
{
"title": "",
"price": "",
"area_id": "",
"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()
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') # 最大入住天数
# 校验必填参数，facility非必填
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='参数错误')
# 判断城区是否存在，防止发布的城区在数据库中没有，进行过滤操作
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(user_id=user_id,
area_id=area_id,
title=title,
price=price,
room_count=room_count,
address=address,
acreage=acreage,
unit=unit,
capacity=capacity,
beds=beds,
deposit=deposit,
min_days=min_days,
max_days=max_days)
# 处理房屋设施信息
facility_ids = house_data.get('facility')
# 如果用户勾选了设施信息，再保存到数据库
if facility_ids:
# ["7", "8", ..]
# 过滤出设施数据在数据库中存在的数据
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='保存数据成功', data={"house_id": house.id})
def save_house_info():
"""
保存房子的信息
接收参数
{
房屋标题
"title":"",
房屋价格
"price":"",
所在城区
"area_id":"",
详细地址
"address":"",
房屋数量
"room_count":"",
房屋面积
"acreage":"",
房屋描述
"unit":"",
房屋能住人数
"capacity":"",
房屋卧床配置
"beds":"",
房屋押金
"deposit":"",
最少入住天数
"min_days":"",
最多入住天数
"max_days":"",
房间设施配置(可传可不传)
"facility":[]
}
格式:json
return: 房屋id 格式json
"""
# 接收参数
user_id = g.user_id
house_dict = request.get_json()
title = house_dict.get("title")
price = house_dict.get("price")
area_id = house_dict.get("area_id")
address = house_dict.get("address")
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, area_id, address, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errnum=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(errnum=RET.PARAMERR, errmsg=u"输入参数不合法")
# 判断城区id是否合法
try:
area = Area.query.get(area_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errnum=RET.DBERR, errmsg=u"数据库异常")
if area is None:
return jsonify(errnum=RET.NODATA, errmsg=u"城区不存在")
# 判断房屋数目 房屋人数 房屋面积 最少入住天数 最多入住天数是否合法
try:
room_count = int(room_count)
capacity = int(capacity)
acreage = float(acreage)
min_days = int(min_days)
max_days = int(max_days)
except Exception as e:
current_app.logger.error(e)
return jsonify(errnum=RET.PARAMERR, errmsg=u"参数错误")
# 业务处理
# 创建房屋模型类对象, 把用户填写的数据添加进去
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)
# 接收房屋设施信息
facility_ids = house_dict.get("facility")
if facility_ids:
# 用有效数据
# 查询数据库, 读取设施信息
# select * from ih_facility_info where id in [] 等价于下面的那条查询语句
try:
facilities = Facility.query.filter(
Facility.id.in_(facility_ids)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errnum=RET.DBERR, errmsg=u"数据库查询失败")
if facilities:
# 把房屋设施信息添加到house对象中, 会自动添加到第三张表中
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(errnum=RET.DBERR, errmsg=u"保存房屋数据失败")
# 返回应答
# 保存成功
return jsonify(errnum=RET.OK, errmsg=u"保存成功", data={"house_id": house.id})
def save_house_info():
"""保存新发布的房源信息， 包括该房源的设备信息"""
# 1. 获取房源基本信息参数
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')
# 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='参数不完整')
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='参数错误')
# 3. 检查区域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(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)
# 4. 校验是否有设备，若有设备，设备id是否存在
facility_ids = house_data.get('facilities')
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
# 5. 保存房源信息到数据库
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():
"""
存储房屋信息
{
'title':'',
'price':'',
'area_id':'',
'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')
unit = house_data.get('unit')
acreage = house_data.get('acreage')
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, unit, acreage,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, msg=u'缺少参数')
# 判断价格、押金格式是否正确
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
current_app.loggere.error(e)
return jsonify(errno=RET.PARAMERR, msg=u'请输入正确的价格，数字类型，最多2位小数')
# 判断地区id是否在数据库中存在
try:
area = Area.query.get(area_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, msg=u'数据库错误')
if area is None:
return jsonify(errno=RET.DBERR, msg=u'城区不存在')
# 保存房屋信息
house = House(
user_id=user_id,
area_id=area_id,
title=title,
price=price,
address=address,
room_count=room_count,
unit=unit,
acreage=acreage,
capacity=capacity,
beds=beds,
deposit=deposit,
min_days=min_days,
max_days=max_days,
)
# 先进行session存储，暂不提交，无需try。 house、facility一并提交，要么都提交成功，要么都失败
# 处理房屋设施信息
facility_ids = house_data.get('facility')
# 如果用户勾选了信息，在保存数据 ['1','2','3']
if facility_ids:
try: # select * from Facility where id in []
facilities = Facility.query.filter(
Facility.id.in_(facility_ids)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, msg=u'数据库异常')
if facilities:
# 表示有合法数据
house.facilities = facilities
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, msg=u'保存数据失败')
# 成功
return jsonify(errno=RET.OK, msg='创建成功', data={'house_id': house.id})
def save_house_info():
"""保存房屋的基本信息"""
user_id = g.user_id
# 获取房屋信息
# 前端发送过来的json数据
# {
# "title": "",
# "price": "",
# ""
# }
house_dict = request.get_json()
title = house_dict.get("title")
price = house_dict.get("price")
area_id = house_dict.get("area_id")
address = house_dict.get("address")
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, area_id, address, room_count, acreage, unit, capacity, beds, deposit, max_days, min_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="参数错误")
# 校验城区是否存在
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(
user_id=user_id,
area_id=area_id,
title=title,
price=price,
address=address,
room_count=room_count,
acreage=acreage,
unite=unit,
capacity=capacity,
beds=beds,
deposit=deposit,
min_days=min_days,
max_days=max_days
)
# 处理房屋设施信息.1:5000/api/v1.0/houses/image
facility_ids = house_dict.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 sava_house_info():
"""保存房屋的基本信息,前段发送过来的json数据"""
# 数据参数
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.DBERR, errmsg="参数有误")
# 保存信息
user_id = g.user_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)
# 处理房屋的设施信息
facility_id_list = house_data.get("facility")
if facility_id_list:
# 表示用户勾选了房屋设施
# 过滤用户传送的不合理的设施id
# select * from facility where id in (facility_id_list)
try:
facility_list = Facility.query.filter(
Facility.id.in_(facility_id_list)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库异常")
# 为房屋添加设施信息
if facility_list:
house.facilities = facility_list
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="保存成功", data={"house_id": house.id})
def save_house_info():
"""
保存发布房屋的信息:
1. 接收参数并进行参数校验
2. 创建House对象并保存房屋的基本信息
3. 将房屋的信息添加进数据库
4. 返回应答，发布房屋信息成功
"""
# 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") # [1, 3, 4]
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_id": house.id})
def save_house_info():
#1.获取参数
req_data = request.data
req_dict = json.loads(req_data)
title = req_dict.get("title")
price = req_dict.get("price")
area_id = req_dict.get("area_id")
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")
#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="参数不完整")
#校验单价和押金
try:
price = float(price)
deposit = float(deposit)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="参数填写有误")
#3.根据参数创建房屋对象
house = House(user_id=g.user_id,
title=title,
price=price,
area_id=area_id,
address=address,
room_count=room_count,
acreage=acreage,
unit=unit,
capacity=capacity,
beds=beds,
deposit=deposit,
min_days=min_days,
max_days=max_days)
#设置房屋的设施信息
facility_id_list = req_dict.get("facility")
if facility_id_list is not None:
try:
facilisty_list = Facility.query.filter(
Facility.id.in_(facility_id_list)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询异常")
if facilisty_list is not None:
house.facilities = facilisty_list
#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.SESSIONERR, errmsg="保存失败")
#5.返回
return jsonify(errno=RET.OK, errmsg="保存成功", 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 release_new_houseing_sources():
"""保存房屋的基本信息
:accept:
{
"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
accept_json = request.get_json()
title = accept_json.get("title")
price = accept_json.get("price")
area_id = accept_json.get("area_id")
address = accept_json.get("address")
room_count = accept_json.get("room_count")
acreage = accept_json.get("acreage")
unit = accept_json.get("unit")
capacity = accept_json.get("capacity")
beds = accept_json.get("beds")
deposit = accept_json.get("deposit")
min_days = accept_json.get("min_days")
max_days = accept_json.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.DATAERR, errmsg="data missing")
try:
price = float(price) * 100
deposit = float(deposit) * 100
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="data missing")
#判断城区ID是否存在
try:
area = Area.query.get(area_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="Mysql Error")
if not area:
return jsonify(errno=RET.NODATA, errmsg="No Data")
# 保存房屋信息
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,
)
facility = accept_json.get("facility")
print("facility", facility)
if facility:
try:
facility = Facility.query.filter(Facility.id.in_(facility)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="Mysql Error")
if not facility:
return jsonify(errno=RET.NODATA, errmsg="Data Not Exist")
if facility:
house.facilities = facility
#提交数据到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="Mysql Data Commit Error")
return jsonify(errno=RET.OK, errmsg="OK", data={"house_id": house.id})
def set_house_info():
"""设置房屋信息
前端发送来的json数据
{
"title":"",
"price":"",
"area_id":"1",
"address":"",
"room_count":"",
"acreage":"",
"unit":"",
"capacity":"",
"beds":"",
"deposit":"",
"min_days":"",
"max_days":"",
"facility":["7","8"]
}
"""
# 获取参数
house_data = request.get_json()
if not house_data:
return jsonify(error_code=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(error_code=RET.PARAMERR, err_msg="参数不完整")
# 判断price 和 deposit
try:
price = int(float(price) * 100)
deposit = int(float(price) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(error_code=RET.PARAMERR, errmsg="参数有误")
# 业务处理
# 保存房屋信息
user_id = g.user_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)
# 获取房屋的设施信息
facility_id_list = house_data.get("facility")
if facility_id_list:
# 用户勾选了设施
# 筛选掉不合理的设施
try:
facility_list = Facility.query.filter(
Facility.id.in_(facility_id_list)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(error_code=RET.DBERR, errmsg="数据库异常")
if facility_list:
house.facilities = facility_list
try:
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="保存房屋信息失败")
# 返回值
return jsonify(error_code=RET.OK,
errmsg="保存成功",
data={"house_id": house.id})
def save_house_info():
"""
保存房屋信息
{
"title": "",
"price": "",
"area_id": "1",
"address": "",
"room_count": "",
"acreage": "",
"unit": "",
"capacity": "",
"deposit": "",
"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, max_days, min_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="参数错误")
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(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)
facility_ids = house_data.get("facility")
if facility_ids:
try:
facilitys = 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 facilitys:
house.facilities = facilitys
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():
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_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():
"""
保存房源信息
格式： json
: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="参数不完整")
# 判断用户输入的房屋单价和押金是否为正确参数，通过存入数据库字段单位分，如果用户输入的值不能转换为float和int类型，说明参数错误
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(
user_id=user_id,
title=title,
price=price,
area_id=area_id,
address=address,
room_count=room_count,
acreage=acreage,
unit=unit,
capacity=capacity,
beds=beds,
deposit=deposit,
min_days=min_days,
max_days=max_days
)
# 获取设备
facility_ids = house_data.get("facility")
# 对获取设备设施字段的值进行判断,下判断这个值存不存在，当用户勾选设备设施时，举例facility_ids值为[2,4]
if facility_ids:
# 通过Facility类中的id值使用in_方法查询其中的id
# select * from ih_facility_info where id in 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_house_info():
"""保存房屋的基本信息
前端发送过来的json数据
{
"title":"",
"price":"",
"area_id":"1",
"address":"",
"room_count":"",
"acreage":"",
"unit":"",
"capacity":"",
"beds":"",
"deposit":"",
"min_days":"",
"max_days":"",
"facility":["7","8"]
}
"""
# 一. 获取参数
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="参数不完整")
# 前端有可能传递的不是flost/int. 需要对价格和押金做转换
# 服务器为了避免小数点精确度的影响, 最好保存成int类型. 以分为单位
# 当前项目的需求, 价格没有小数点
try:
price = int(float(price) * 100)
deposit = int(float(deposit) * 100)
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DATAERR, errmsg='价格有误')
# 三. 保存房屋信息
# 1. 创建房屋对象
# 谁订的房子
user_id = g.user_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)
# 2. 处理房屋的设施信息 --> 在这里获取房屋设施的信息, 如果有信息, 拼接到房屋对象里. 如果没有直接返回
# 2.1 先去请求中获取facility数据
facility_id_list = house_data.get('facility')
# 2.2 再去查询数据库中是否存在-->避免前端传递了错误数据(相当于参数效验)
if facility_id_list:
try:
# 去数据库查询, 所传入的设施ID是否存在
facility_list = Facility.query.filter(
Facility.id.in_(facility_id_list)).all()
# select * from faclity where id in (facality_id_list)
except Exception as e:
logging.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库查询异常')
# 2.3查询到了, 添加到house数据中
if facility_list:
house.facilities = facility_list
# 3. 保存数据库
try:
db.session.add(house)
db.session.commit()
except Exception as e:
logging.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='数据库添加异常')
# 四. 返回数据
# 这里需要返回房屋的ID信息. 因为发布成功后, 会进入发布房屋图片的界面.
# 设置图片, 必须知道房屋的ID才行
return jsonify(errno=RET.OK,
errmsg='设置房屋信息成功',
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():
"""保存房屋基本信息"""
user_id = g.user_id
house_data = request.get_json()
#接收参数
title = house_data.get("title") # 房屋名称
price = house_data.get("price") # 房屋单价
ared_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, ared_id, address, room_count, acreage, unit,
capacity, beds, deposit, min_days, max_days
]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
#校验金额
try:
price = int(price)
deposit = int(deposit)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="金额参数错误")
#判断城区id是否存在
try:
area = Area.query.get(ared_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(user_id=user_id,
ared_id=ared_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)
#处理房屋的设施信息
facility_ids = house_data.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="数据库异常")
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.DBERR, errmsg="OK", data={"house": 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 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 获取参数 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 set_house_info():
"""
房源基本信息的发布
请求参数: json对象
{
"title":"",
"price":"",
"area_id":"1",
"address":"",
"room_count":"",
"acreage":"",
"unit":"",
"capacity":"",
"beds":"",
"deposit":"",
"min_days":"",
"max_days":"",
"facility":["7","8"]
}
:return: 正常 json对象+ 房屋id 异常json对象
"""
# 获取参数
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") # 最大入住天数
# 参数校验
# 参数完整
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)
min_days = int(min_days)
max_days = int(max_days)
capacity = int(capacity)
acreage = int(float(acreage) * 100)
room_count = int(room_count)
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.PARAMERR, errmsg="城区信息异常")
# 房屋基本信息保存
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)
# 获取房屋设施的配置数据
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.logegr.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="数据保存异常")
# 保存成功，将house_id 返回给前端的图片上传
return jsonify(errno=RET.OK, errmsg="Ok", 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 save_house_info():
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='参数错误')
user_id = g.user_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)
# 处理房屋的设施信息
facility_id_list = house_data.get('facility')
if facility_id_list:
# 表示用户勾选了房屋设施
# 过滤用户传送的不合理的设施id
try:
facility_list = Facility.query.filter(
Facility.id.in_(facility_id_list)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库异常')
# !!!为房屋添加设施信息
if facility_list:
house.facilities = facility_list
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='保存成功', 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 set_house_info():
"""设置房屋信息
前端发送来的json数据
{
"title":"",
"price":"",
"area_id":"1",
"address":"",
"room_count":"",
"acreage":"",
"unit":"",
"capacity":"",
"beds":"",
"deposit":"",
"min_days":"",
"max_days":"",
"facility":["7","8"]
}
"""
# 获取参数
house_data = request.get_json()
if not house_data:
return jsonify(error_code=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(error_code=RET.PARAMERR, err_msg="参数不完整")
# 判断price 和 deposit
try:
price = int(float(price) * 100)
deposit = int(float(price) * 100)
except Exception as e:
current_app.logger.error(e)
return jsonify(error_code=RET.PARAMERR, errmsg="参数有误")
# 业务处理
# 保存房屋信息
user_id = g.user_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
)
# 获取房屋的设施信息
facility_id_list = house_data.get("facility")
if facility_id_list:
# 用户勾选了设施
# 筛选掉不合理的设施
try:
facility_list = Facility.query.filter(Facility.id.in_(facility_id_list)).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(error_code=RET.DBERR, errmsg="数据库异常")
if facility_list:
house.facilities = facility_list
try:
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="保存房屋信息失败")
# 返回值
return jsonify(error_code=RET.OK, errmsg="保存成功", data={"house_id": house.id})
