def booking():
data = {}
data['user_id'] = session['user_id']
data['begin_date'] = request.form.get('startDate')
data['end_date'] = request.form.get('endDate')
data['days'] = request.form.get('days')
data['house_id'] = request.form.get('house_id')
data['house_price'] = House.query.get(request.form.get('house_id')).price
data['amount'] = data['house_price'] * data['days']
data['status'] = 'WAIT_ACCEPT'
order = Order(**data)
order.add_update()
return jsonify(SUCCESS)
def add_order():
"""添加订单"""
# 获取参数
request_dict = request.json
house_id = request_dict.get('house_id')
sd = request_dict.get('sd')
ed = request_dict.get('ed')
# 校验参数
if not all([house_id, sd, ed]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少必要参数')
try:
start_date = datetime.strptime(sd, '%Y-%m-%d')
end_date = datetime.strptime(ed, '%Y-%m-%d')
assert start_date < end_date, Exception('参数错误')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
try:
house = House.query.filter(House.id == house_id).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询数据失败')
if not house:
return jsonify(errno=RET.PARAMERR, errmsg='房屋不存在')
# 查询订单是否冲突
try:
conflict_orders = Order.query.filter(start_date < Order.begin_date,
Order.end_date < end_date,
Order.house_id == house_id).all()
except Exception as e:
return jsonify(errno=RET.DBERR, errmsg='查询数据失败')
if conflict_orders:
return jsonify(errno=RET.PARAMERR, errmsg='预定日期冲突')
# 保存订单
order = Order()
order.user_id = g.user_id # 下订单的用户编号
order.house_id = house.id # 预订的房间编号
order.begin_date = start_date # 预订的起始时间
order.end_date = end_date # 预订的结束时间
order.days = (end_date - start_date).days # 预订的总天数
order.house_price = house.price # 房屋的单价
order.amount = order.days * house.price # 订单的总金额
try:
db.session.add(order)
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')
def create_order():
"""添加订单"""
# 获取参数
house_id = request.json.get('house_id')
start_date = request.json.get('start_date')
end_date = request.json.get('end_date')
# 检查数据
if not all([house_id,start_date,end_date]):
return jsonify(re_code=RET.PARAMERR,msg='参数有误')
# 查询订单时间段是否和已有订单冲突
try:
start_date = datetime.strptime(start_date,'%Y-%m-%d')
end_date = datetime.strptime(end_date,'%Y-%m-%d')
except Exception as e:
current_app.logger.debug(e)
return jsonify(re_code=RET.PARAMERR,msg='日期格式错误')
# 判断房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.debug(e)
return jsonify(re_code=RET.DBERR,msg='查询房屋失败')
if not house:
return jsonify(re_code=RET.NODATA,msg='房屋不存在')
# 查询冲突房屋
try:
conflict_house = Order.query.filter(Order.house_id == house_id,Order.end_date > start_date,Order.begin_date < end_date).first()
except Exception as e:
current_app.logger.debug(e)
return jsonify(re_code=RET.DBERR,msg='查询冲突房屋失败')
if conflict_house:
return jsonify(re_code=RET.DATAERR,msg='房屋被预定')
# 计算时间
days = (end_date-start_date).days
# 创建订单模型类
order = Order()
order.user_id = g.user_id
order.house_id = house_id
order.begin_date = start_date
order.end_date = end_date
order.days = days
order.house_price = house.price
order.amount = house.price*days
try:
db.session.add(order)
db.session.commit()
except Exception as e:
current_app.logger.debug(e)
return jsonify(re_code=RET.DBERR,msg='订单保存失败')
return jsonify(re_code=RET.OK,msg='OK')
def save_order():
"""保存订单"""
user_id = g.user_id
order_data = request.get_json()
if not order_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
house_id = order_data.get("house_id")
start_date_str = order_data.get("start_date")
end_date_str = order_data.get("end_date")
if not all((house_id, start_date_str, end_date_str)):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
start_date = datetime.datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.datetime.strptime(end_date_str, "%Y-%m-%d")
assert start_date <= end_date
days = (end_date - start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="日期格式错误")
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取房屋信息失败")
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋不存在")
if user_id == house.user_id:
return jsonify(errno=RET.ROLEERR, errmsg="不能预订自己的房屋")
order_status_li = Order.order_status_li
try:
count = Order.query.with_for_update().filter(Order.house_id == house_id, Order.begin_date <= end_date,
Order.end_date >= start_date,
Order.status.notin_(order_status_li)).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="检查出错，请稍候重试")
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg="房屋已被预订")
amount = days * house.price
order = Order(
house_id=house_id,
user_id=user_id,
begin_date=start_date,
end_date=end_date,
days=days,
house_price=house.price,
amount=amount
)
try:
db.session.add(order)
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={"order_id": order.id})
def create_order():
house_id = request.get_json().get("housed_id")
start_date_str = request.get_json().get("start_date")
end_date_str = request.get_json().get("end_date")
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
try:
house = House.query.get(house_id)
start_date = datetime.striptime(start_date_str, "%Y-%m-%d")
end_date = datetime.strptime(end_date_str, "%Y-%m-%d")
except Exception as e:
current_app.logger.error(e)
return jsonify(errrno=RET.DBERR, errmsg="查询异常")
if not house:
return jsonify(errno=RET.NODATA, errmsg="＝该房子不存在")
try:
conflict_orders = Order.query.filter(start_date < Order.end_date,
end_date > Order.start_date)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询订单异常")
if conflict_orders:
return jsonify(errno=RET.DATAERR, errmsg="该房子时间段内已被锁定")
order = Order()
days = (end_date - start_date).days
order.user_id = g.user_id
order.user_id = g.user_id
order.house_id = house_id
order.begin_date = start_date
order.days = days
order.house_price = house.price
order.amount = house.price * days
try:
db.session.add(order)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="订单创建失败")
return jsonify(errno=RET.OK, errmsg="创建成功")
def save_order(user_id, house_id, start_date_str, end_date_str, price):
flask_app.app_context().push()
# 确保用户预订的时间内，房屋没有被别人下单
start_date = datetime.datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.datetime.strptime(end_date_str, "%Y-%m-%d")
try:
# 查询时间冲突的订单数
count = Order.query.filter(Order.house_id == house_id,
Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
print(e)
return -1
if count > 0:
return -2
# 订单总额
days = (end_date - start_date).days + 1
amount = days * price
# 保存订单数据
order = Order()
order.house_id = house_id
order.user_id = user_id
order.begin_date = start_date
order.end_date = end_date
order.days = days
order.house_price = price
order.amount = amount
try:
db.session.add(order)
db.session.commit()
except Exception as e:
print(e)
db.session.rollback()
return -1
return order.id
def get_order():
"""处理订单"""
# 获取参数
json_dict = request.get_json()
house_id = json_dict.get('house_id')
start_date_str = json_dict.get('start_date')
end_date_str = json_dict.get('end_date')
# 校验参数
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errcode=RET.DATAERR, errmsg='数据不全')
# 日期是否正确
try:
start_date = datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.strptime(end_date_str, "%Y-%m-%d")
except Exception as e:
current_app.logger.error(e)
return jsonify(errcode=RET.DATAERR, errmsg='日期格式错误')
if end_date < start_date:
return jsonify(errcode=RET.DATAERR, errmsg='日期时间错误')
# 房源信息
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errcode=RET.DBERR, errmsg='查询数据库失败')
if not house:
return jsonify(errcode=RET.DBERR, errmsg='房源不存在')
# 订单中是否存在冲突
try:
orders = Order.query.filter(Order.house_id==house_id, Order.begin_date<=end_date, Order.end_date>=start_date).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errcode=RET.DBERR, errmsg='查询数据库失败')
if orders:
return jsonify(errcode=RET.PARAMERR, errmsg='订单冲突')
# 业务处理
days = int((end_date-start_date).days) + 1
order_info = {
'user_id': g.user_id,
'house_id': house_id,
'begin_date': start_date_str,
'end_date': end_date_str,
'days': days,
'house_price': house.price,
'amount': int(house.price)*int(days)
}
order = Order(use_id=g.user_id, house_id=house_id, \
begin_date=start_date, end_date=end_date, \
days=days, house_price=house.price,\
amount=int(house.price)*int(days))
try:
db.session.add(order)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errcode=RET.DBERR, errmsg='保存数据失败')
return jsonify(errcode=RET.OK, errmsg='OK')
def save_order():
"""保存订单"""
user_id = g.user_id
#获取参数
order_data = request.get_json()
if not order_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
#提取参数
house_id = order_data.get("house_id") # 预定的房屋编号
start_date_str = order_data.get("start_data") # 预定的起始时间
end_date_str = order_data.get("end_date") # 预定的结束时间
#参数检查
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
#日期格式检查
try:
#
start_date = datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.strptime(end_date_str, "%Y-%m-%d")
assert start_date <= end_date
#计算预定的天数
days = (end_date - start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="日期格式错误")
#验证房屋id
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取房屋信息失败")
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋不存在")
#预定的房屋是否是房东自己的
if user_id == house.user_id:
return jsonify(errno=RET.ROLEERR, errmsg="不能预定自己的房屋")
#查询订单是否有冲突
try:
count = Order.query.filter(Order.house_id == house_id,
Order.begin_date <= end_date,
Order.end_data >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询错误")
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg="房屋已经被预定")
#订单总额
amount = days * house.price
#保存订单数据
order = Order(user_id=user_id,
house_id=house_id,
begin_date=start_date,
end_date=end_date,
days=days,
house_price=house.price,
amount=amount)
try:
db.session.add(order)
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={"order_id": order.id})
def save_order():
"""保存订单"""
# 获取用户id
user_id = g.user_id
# 获取参数
order_data = request.get_json()
if not order_data:
return jsonify(error_code=RET.PARAMERR, errmsg="参数错误")
house_id = order_data.get("house_id") # 预定的房屋编号
start_data_str = order_data.get("start_date") # 预定的起始时间
end_data_str = order_data.get("end_date") # 预定的结束时间
# 参数校验
if not all([house_id, start_data_str, end_data_str]):
return jsonify(error_code=RET.PARAMERR, errmsg="参数不完整")
# 日期格式检验
try:
# 将请求的时间参数字符串转换为datetime类型
start_date = datetime.strptime(start_data_str, "%Y-%m-%d")
end_date = datetime.strptime(end_data_str, "%Y-%m-%d")
assert start_date <= end_date
# 计算预定的天数
days = (end_date - start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(error_code=RET.PARAMERR, errmsg="日期格式错误")
# 查询房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(error_code=RET.DBERR, errmsg="获取房屋信息失败")
if not house:
return jsonify(error_code=RET.NODATA, errmsg="房屋不存在")
# 预定的房屋是否是房东自己的
if user_id == house.user_id:
return jsonify(error_code=RET.ROLEERR, errmsg="不能预定自己的房屋")
# 确保用户预定的时间内，房屋没有被别人下单
try:
# 查询时间冲突的订单
count = Order.query.filter(Order.house_id == house.id, Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(error_code=RET.DBERR, errmsg="检查出错，请稍后再试")
if count > 0:
return jsonify(error_code=RET.DATAERR, errmsg="房屋已被预定")
# 订单总额
amount = days * house.price
# 保存订单数据
order = Order()
order.house_id = house_id
order.user_id = user_id
order.begin_date = start_date
order.end_date = end_date
order.days = days
order.house_price = house.price
order.amount = amount
try:
db.session.add(order)
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="ok", data={"order_id": order.id})
def submit_order():
"""
1.获取参数
2.校验参数
3.查询冲突订单
4.创建订单
5.设置订单参数
6.提交到数据库
7.返回响应信息给前端
:return:
"""
# 1.获取参数
user_id = g.user_id
data_dict = request.json
house_id = data_dict.get("house_id")
start_date_str = data_dict.get("start_date")
end_date_str = data_dict.get("end_date")
# 2.校验参数
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
try:
start_date = datetime.strptime(start_date_str, '%Y-%m-%d')
end_date = datetime.strptime(end_date_str, '%Y-%m-%d')
assert start_date < end_date, Exception('开始日期大于结束日期')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="日期格式错误")
# 判断房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询异常")
if not house:
return jsonify(errno=RET.DATAERR, errmsg="该房屋不存在")
# 判断房屋是否是当前登录用户的
if user_id == house.user_id:
return jsonify(errno=RET.ROLEERR, errmsg='不能预订自己的房屋')
# 3.查询冲突订单
try:
orders = Order.query.filter(Order.house_id == house_id,
start_date < Order.end_date,
end_date > Order.begin_date).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询异常")
if orders:
return jsonify(errno=RET.DATAERR, errmsg="该时间段内已被预定")
# 查询是否存在冲突的订单 # 讲义上面查询冲突订单的方式
# try:
# filters = [Order.house_id == house_id, Order.begin_date < end_date, Order.end_date > start_date]
# count = Order.query.filter(*filters).count()
# except Exception as e:
# logging.error(e)
# return jsonify(errno=RET.DBERR, errmsg='数据查询错误')
#
# if count > 0:
# return jsonify(errno=RET.DATAERR, errmsg='该房屋已被预订')
# 4.创建订单
order = Order()
days = (end_date - start_date).days
amount = days * house.price
# 5.设置订单参数
order.user_id = g.user_id
order.house_id = house_id
order.begin_date = start_date
order.end_date = end_date
order.days = days
order.house_price = house.price
order.amount = amount
# 6.提交到数据库
try:
db.session.add(order)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="保存到数据库失败")
# 7.返回响应信息给前端
return jsonify(errno=RET.OK, errmsg="订单保存成功")
def save_order():
"""保存订单"""
# 一. 获取数据
# 获取用户id
user_id = g.user_id
# 获取参数,校验参数
order_data = request.get_json()
if not order_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 进一步获取详细参数信息,house_id/start_date/end_date
house_id = order_data.get("house_id")
start_date_str = order_data.get("start_date")
end_date_str = order_data.get("end_date")
# 二. 校验参数完整性
# 2.1 完整性校验
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 2.2 对日期格式化,datetime
try:
start_date = datetime.datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.datetime.strptime(end_date_str, "%Y-%m-%d")
# 断言订单天数至少1天
assert start_date <= end_date
# 计算预订的天数
days = (end_date - start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="日期格式错误")
# 三. 业务逻辑处理
# 3.1 查询房屋是否存在
try:
# House.query.filter_by(id=house_id).first()
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取房屋信息失败")
# 校验查询结果
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋不存在")
# 3.2 判断用户是否为房东
if user_id == house.user_id:
return jsonify(errno=RET.ROLEERR, errmsg="不能预订自己的房屋")
# 3.3 查询是否被别人预定
try:
# 查询时间冲突的订单数
count = Order.query.filter(Order.house_id == house_id,
Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="检查出错，请稍候重试")
# 校验查询结果
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg="房屋已被预订")
# 3.4 计算房屋总价
amount = days * house.price
# 生成模型类对象,保存订单基本信息:房屋/用户/订单的开始日期/订单的结束日期/天数/价格/总价
order = Order()
order.house_id = house_id
order.user_id = user_id
order.begin_date = start_date
order.end_date = end_date
order.days = days
order.house_price = house.price
order.amount = amount
# 3.5 保存订单数据到数据库
try:
db.session.add(order)
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={"order_id": order.id})
def save_order():
"""
保存订单
需要参数：用户id，房屋id，入住日期
数据格式：json
:return:
"""
# 获取用户id
user_id = g.user_id
# 获取参数，房屋id，入住时间，结束时间
order_data = request.get_json()
if not order_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
house_id = order_data.get("house_id") # 预订的房屋编号
start_date_str = order_data.get("start_date") # 入住时间
end_date_str = order_data.get("end_date") # 结束时间
# 检验参数
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 处理时间
try:
# 转换时间格式，计算入住的天数
start_date = datetime.datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.datetime.strptime(end_date_str, "%Y-%m-%d")
assert start_date <= end_date
# 计算入住天数，需额外加一
days = (end_date - start_date).days + 1 # datetime.timedelta
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="日期格式错误")
# 判断房子是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库异常")
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋信息不存在")
# 判断预定用户是否是房东本人
if user_id == house.user_id:
return jsonify(errno=RET.ROLEERR, errmsg="不能预订自己的房屋")
# 判断这段时间内房屋是否被下单
try:
# 查询时间冲突的订单数
count = Order.query.filter(Order.house_id == house_id,
Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="检查出错，请稍后重试！")
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg="房屋已被预订")
# 计算总额
amount = days * house.price
# 保存数据
order = Order(user_id=user_id,
house_id=house_id,
begin_data=start_date,
end_date=end_date,
days=days,
house_price=house.price,
amount=amount)
try:
db.session.add(order)
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={"order_id": order.id})
def save_order():
"""保存用户的订单"""
user_id = g.user_id
# 获取参数
order_data = request.get_json()
if not order_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 获取用户预订的房屋编号，入住时间以及离开时间
house_id = order_data.get("house_id")
start_date_str = order_data.get("start_date")
end_date_str = order_data.get("end_date")
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 检查日期格式
try:
# 将str格式的日期数据转换成datetime格式的日期数据
start_date = datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.strptime(end_date_str, "%Y-%m-%d")
assert start_date <= end_date # 使用断言就行判断
# 计算预订的天数
days = (end_date - start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="日期格式不正确")
# 查询用户预订的房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取房屋信息失败")
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋不存在")
# 判断房东预订的房屋是不是自己的发布的房屋
if user_id == house.user_id:
return jsonify(errno=RET.ROLEERR, errmsg="不能预订自己发布的房屋")
# 检查用户预订的时间内，房屋没有被别人下单
try:
# 查询时间冲突的订单数 select count(*) from ih_order_info where ()
count = Order.query.filter(Order.house_id == house_id,
Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="系统繁忙，请稍候重试")
# 如果查询的订单冲突数大于0，则说明房屋在用户预订时间内，已被他人预订
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg="房屋已被预订")
# 计算订单总额
amount = house.price * days
# 保存订单数据
order = Order(house_id=house_id,
user_id=user_id,
begin_date=start_date,
end_date=end_date,
days=days,
house_price=house.price,
amount=amount)
# 提交数据到数据库
try:
db.session.add(order)
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={"order_id": order.id})
def save_order():
'''保存订单'''
# 获取与校验参数完整性
user_id = g.user_id
order_data = request.get_json()
if not order_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
house_id = order_data.get('house_id')
start_date = order_data.get('start_date')
end_date = order_data.get('end_date')
if not all([house_id, start_date, end_date]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 校验日期
try:
start_date = datetime.strptime(start_date, '%Y-%m-%d')
end_date = datetime.strptime(end_date, '%Y-%m-%d')
assert start_date <= end_date
# 此处计算预定天数，应明确标识对天数的设定(如中午12点之前不计入当天等)
days = (end_date - start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="时间格式错误")
# 校验房屋
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取数据失败")
if not house:
return jsonify(errno=RET.NODATA, errmsg='房屋信息有误')
# 判断房东信息
if house.user_id == user_id:
return jsonify(errno=RET.ROLEERR, errmsg='房东不可以预定自己的房间')
# 判断订单冲突情况
try:
count = Order.query.filter(Order.house_id == house_id,
Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取数据失败")
print(count)
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg='房屋已被预定，存在冲突')
# 生成订单
amount = days * house.price
order = Order(
user_id=user_id,
house_id=house_id,
begin_date=start_date,
end_date=end_date,
days=days,
house_price=house.price,
amount=amount,
)
try:
db.session.add(order)
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={'order_id': order.id})
def save_order():
"""保存订单"""
user_id = g.user_id
# 获取参数
order_data = request.get_json()
if not order_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
house_id = order_data.get('house_id') # 预定的房屋编号
start_date_str = order_data.get('start_date') # 预定的起始时间
end_date_str = order_data.get('end_date') # 预定的结束时间
# 参数检验
if not all(house_id, start_date_str, end_date_str):
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 日期格式检查
try:
# 将请求的时间参数字符串转换为datetime类型
start_date = datetime.datetime.strptime(start_date_str, '%Y-%m-%d')
end_date = datetime.datetime.strptime(end_date_str, '%Y-%m-%d')
assert start_date <= end_date
# 计算预定的天数
days = (end_date - start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='日期格式错误')
# 查询房屋是否存在
try:
house = Houses.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='获取房屋信息失败')
if not house:
return jsonify(errno=RET.NODATA, errmsg='房屋不存在')
# 预定的房屋是否是房东自己的
if user_id == house.user_id:
return jsonify(errno=RET.ROLEERR, errmsg='不能预定自己的房屋')
# 确保用户预定的时间内，房屋没有被别人下单
try:
# 查询时间冲突的订单数
count = Order.query.filter(Order.house_id == house_id, Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='检查出错,请稍后重试')
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg='房屋已被预定')
# 保存订单数据
order = Order(
house_id=house_id,
user_id=user_id,
begin_date=start_date,
end_date=end_date,
days=days,
house_price=house.price,
amount=amount
)
try:
db.session.add(order)
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={"order_id": order.id})
def add_order():
"""
下单
1. 获取参数
2. 校验参数
3. 查询指定房屋是否存在
4. 判断当前房屋的房主是否是登录用户
5. 查询当前预订时间是否存在冲突
6. 生成订单模型，进行下单
7. 返回下单结果
:return:
"""
param_dict = request.json
start_date_str = param_dict.get('start_date')
end_date_str = param_dict.get('end_date')
house_id = param_dict.get('house_id')
user_id = g.user_id
# 校验参数
if not all([start_date_str, end_date_str, house_id]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不足')
# 查询房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询房屋数据异常")
if not house:
return jsonify(errno=RET.NODATA, errmsg='房屋不存在')
# 判断当前房屋的房主是否是登录用户
if user_id == house.user_id:
return jsonify(errno=RET.DATAERR, errmsg='用户为屋主,不能预定')
# 转换时间格式,查询当前预订时间是否存在冲突
start_date = datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.strptime(end_date_str, "%Y-%m-%d")
try:
order_count = Order.query.filter(Order.house_id == house_id, Order.begin_date < end_date, Order.end_date > start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询订单数据异常")
if order_count > 0:
return jsonify(errno=RET.DATAERR, errmsg='该时间段已有订单')
# 计算入住天数以及总价格
days = (end_date-start_date).days + 1
amount = house.price * days
# 生成订单模型，进行下单
order = Order()
order.user_id = user_id
order.house_id = house_id
order.begin_date = start_date
order.end_date = end_date
order.house_price = house.price
order.days = days
order.amount = amount
try:
db.session.add(order)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存订单数据异常")
# 返回数据
return jsonify(errno=0, errmsg='OK', data={'order_id': order.id})
def save_order():
"""保存订单"""
# 获取数据
# 获取用户id
user_id = g.user_id
# 获取参数
order_data = request.get_json()
# 判断参数是否存在
if not order_data:
return jsonify(errno=RET.PARAMERR,errmsg="参数错误")
# 获取数据,预订的房屋编号,预订的起始时间,预订结束的时间
house_id = order_data.get("house_id")
start_date_str = order_data.get("start_date")
end_date_str = order_data.get("end_date")
# 校验参数
# 判断数据是否完整
if not all([house_id,start_date_str,end_date_str]):
return jsonify(errno=RET.PARAMERR,errmsg="参数错误")
# 日期格式检查
try:
# 将时间转为datetime类型
start_date = datetime.strptime(start_date_str,"%Y-%m-%d")
end_date = datetime.strptime(end_date_str,"%Y-%m-%d")
# 使用断言判断时间
assert start_date <= end_date
# 计算预订的天数 days转为int类型
days = (end_date-start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR,errmsg="日期格式错误")
# 业务处理
# 查询房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR,errmsg="获取房屋信息错误")
# 判断房子是否存在
if not house:
return jsonify(errno=RET.NODATA,errmsg="获取房屋信息错误")
# 判断预订的房屋是否是房东自己,防止刷单
if user_id == house.user_id:
return jsonify(errno=RET.ROLEERR,errmsg="不能预订自己的房子")
# 防止用户预订的时间内,房屋被其他用户下单
try:
# 查询时间冲突的订单数
count = Order.query.filter(Order.house_id == house_id, Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据库错误")
# 判断是否有冲突的订单数
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg="当前房屋已经被预订了")
# 获取订单总金额
amount = days * house.price
# 保存订单数据
order = Order()
order.house_id = house_id
order.user_id = user_id
order.begin_date = start_date
order.end_date = end_date
order.days = days
order.house_price = house.price
order.amount = amount
try:
db.session.add(order)
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={"order_id": order.id})
def save_order():
"""创建订单"""
user_id = g.user_id
# 获取参数
order_data = request.get_json() # 将json数据转化为字典
if not order_data:
return jsonify(errno=RET.PARAMERR, errmsg=u'未获取到数据')
house_id = order_data.get('house_id')
start_time = order_data.get('sd')
end_time = order_data.get('ed')
if not all([house_id, start_time, end_time]):
return jsonify(errno=RET.PARAMERR, errmsg=u'参数不完整')
# 校验日期
try:
start_time = datetime.strptime(start_time, '%Y-%m-%d')
end_time = datetime.strptime(end_time, '%Y-%m-%d')
assert start_time <= end_time
days = (end_time - start_time).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg=u'日期有误')
# 判断用户是否有尚未支付的订单 如果有就不能下订单
try:
wait_pay_count = Order.query.filter_by(user_id=user_id,
status='WAIT_PAYMENT').count()
except Exception as e:
current_app.logger.error(e)
if wait_pay_count >= 1:
return jsonify(errno=RET.SERVERERR, errmsg=u'你有未支付的订单，请先支付')
# 校验房屋id
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'获取房屋数据失败')
if not house:
return jsonify(errno=RET.DATAEXIST, errmsg=u'房屋不存在')
# 判断入住的天数不能大于最大的入住天数
if house.max_days != 0 and days > house.max_days:
return jsonify(errno=RET.DATAERR,
errmsg=u'不能入住，此房屋最大入住天数为%s天' % house.max_days)
if house.user_id == user_id:
return jsonify(errno=RET.DATAERR, errmsg="自己不能预定自己的房间")
#检查房屋是否被订单
try:
count = Order.query.filter(Order.house_id==house_id, Order.begin_date <= end_time,\
Order.end_date >= start_time).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="检查出错，请稍候重试")
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg="房间已经被预定")
# 总价格
amount = house.price * days
try:
order = Order(user_id=user_id,house_id=house_id,begin_date=start_time,\
end_date=end_time,days=days,house_price=house.price,amount=amount)
db.session.add(order)
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="订单创建成功")
def set_order():
'''
该接口是作为提交订单作用 创建订单
获取house_id,为该house_id的房源创建一个order数据
1判断登陆
2.获取参数
3.参数校验 --数据完整性 --房屋是否存在 --参数格式
4.判断该时间是否存在订单
5.创建订单
6.提交数据库
7.返回响应
'''
# 1.获取参数
json_dict = request.json
house_id = json_dict.get('house_id')
start_date_str = json_dict.get('start_date')
end_date_str = json_dict.get('end_date')
# 2.校验参数
# 校验参数完整性
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg=u'参数不完整')
# 校验参数格式
try:
house_id = int(house_id) # 校验house_id参数格式,并转换成int类型
# 校验时间格式并将字符串格式转换成事件格式
start_date = datetime.datetime.strptime(start_date_str, '%Y-%m-%d')
end_date = datetime.datetime.strptime(end_date_str, '%Y-%m-%d')
if end_date < start_date:
return jsonify(errno=RET.PARAMERR, errmsg=u'无效时间段')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg=u'参数格式有误')
# 校验提交订单的房源是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'房屋数据获取失败')
if not house:
return jsonify(errno=RET.PARAMERR, errmsg=u'房源不存在')
# 4.判断订单是否冲突
try:
conflict_orders = Order.query.filter(
Order.house_id == house_id, Order.end_date > start_date,
end_date > Order.begin_date).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'数据查询失败')
if conflict_orders:
return jsonify(errno=RET.PARAMERR, errmsg=u'该时间已有订单存在')
# 5.创建订单
order = Order()
order.user_id = g.user_id
order.house_id = house_id
order.begin_date = start_date
order.end_date = end_date
order.days = (end_date - start_date).days
order.house_price = house.price
order.amount = house.price * (end_date - start_date).days
# order.status = 'WAIT_ACCEPT' # 默认是WAIT_ACCEPT 可以不用写
# 6.提交数据库
try:
db.session.add(order)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg=u'保存数据失败')
# 7.返回响应
return jsonify(errno=RET.OK, errmsg=u'创建订单成功')
def save_order():
"""保存订单
需要的参数：用户id，房子id，入住与结束的日期
参数要求：json 格式
"""
# 获取用户的 id
user_id = g.user_id
# 获取参数
order_data = request.get_json()
if not order_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
house_id = order_data.get("house_id") # 预订的房屋编号
start_date_str = order_data.get("start_date") # 预订的入住时间
end_date_str = order_data.get("end_date") # 预订的结束时间
# 验证参数的完整性
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 处理日期
try:
# 将接受的日期字符串转换成日期格式
start_date = datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.strptime(end_date_str, "%Y-%m-%d")
assert start_date <= end_date
# 计算预定的天数
days = (end_date - start_date).days + 1 # datetime.timedelta
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='日期格式错误')
# 查询房子是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='获取房屋信息失败')
if not house:
return jsonify(errno=RET.DBERR, errmsg='房子不存在')
# 预定的房屋是否是房东自己
if user_id == house.user_id:
return jsonify(errno=RET.ROLEERR, errmsg='不能预定自己的房屋')
# 确保用户预定的时间内，房屋没有被别人下单
try:
# 查询时间冲突的订单数
count = Order.query.filter(Order.house_id == house_id,
Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='检查出错，请稍后重试')
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg="房屋已被预定")
# 预定总额
amount = days * house.price
# 保存订单数据
order = Order(house_id=house_id,
user_id=user_id,
begin_date=start_date,
end_date=end_date,
days=days,
house_price=house.price,
amount=amount)
try:
db.session.add(order)
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={"order_id": order.id})
def save_order():
"""保存订单"""
user_id = g.user_id
# 获取参数
order_data = request.get_json()
if not order_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
house_id = order_data.get("house_id") # 预订的房屋编号
start_date_str = order_data.get("start_date") # 预订的起始时间
end_date_str = order_data.get("end_date") # 预订的结束时间
# 参数检查
if not all((house_id, start_date_str, end_date_str)):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 日期格式检查
try:
# 将请求的时间参数字符串转换为datetime类型
start_date = datetime.datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.datetime.strptime(end_date_str, "%Y-%m-%d")
# 断言：开始时间小于等于结束时间，否则报错
assert start_date <= end_date
# 计算预订的天数：将计算的时间差转换(.days)为天数
days = (end_date - start_date).days + 1 # datetime.timedelta
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="日期格式错误")
# 查询房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取房屋信息失败")
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋不存在")
# 预订的房屋是否是房东自己的
if user_id == house.user_id: # 如果下单人的id和房屋拥有者的id相同
return jsonify(errno=RET.ROLEERR, errmsg="不能预订自己的房屋")
# 确保用户预订的时间内，房屋没有被别人下单
try:
# 查询时间冲突的订单数 查询出请求房屋和用户选择时间段与这个房屋之前的订单时间段有冲突的条目数
count = Order.query.filter(Order.house_id == house_id,
Order.begin_date <= end_date,
Order.end_date >= start_date).count()
# select count(*) from order where ....
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="检查出错，请稍候重试")
# 如果大于0，表示这个时间段有冲突的订单
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg="房屋已被预订")
# 订单总额
amount = days * house.price
# 保存订单数据
order = Order(
house_id=house_id, # 房屋的id
user_id=user_id, # 下单人的id
begin_date=start_date, # 开始时间
end_date=end_date, # 结束时间
days=days, # 天数
house_price=house.price, # 房屋的单价
amount=amount # 订单的金额
)
try:
db.session.add(order)
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={"order_id": order.id})
def save_order():
"""保存订单"""
# 获取参数 下单用户/房屋id/起始时间/终止时间
user_id = g.user_id
req_dict = request.get_json()
house_id = req_dict.get('house_id')
start_date_str = req_dict.get('start_date')
end_date_str = req_dict.get('end_date')
# 校验参数
# 参数完整性校验
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 房屋id是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询房屋信息失败')
# 时间格式
try:
start_date = datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.strptime(end_date_str, "%Y-%m-%d")
assert end_date >= start_date
# 时间格式可以直接加减
days = (end_date - start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='日期格式有误')
# 判断房屋是否冲突,是否可以预定
# 查询当前要预定的房屋是否有冲突的订单
try:
conflict_count = Order.query.filter(
Order.house_id == house_id, Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询房屋订单数据失败')
if conflict_count:
# 如果有与当前房屋冲突的订单
return jsonify(errno=RET.DATAEXIST, errmsg='当前房屋已被预定')
# 判断下单人是否是房东本人
if user_id == house.user_id:
return jsonify(errno=RET.ROLEERR, errmsg='无法预定本人发布的房屋')
# 保存订单数据
# 生成订单对象
order = Order()
order.user_id = user_id,
order.house_id = house_id,
order.begin_date = start_date,
order.end_date = end_date,
order.days = days,
order.house_price = house.price,
order.amount = (days * house.price)
try:
db.session.add(order)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存订单失败')
# 返回
return jsonify(errno=RET.OK, errmsg='保存订单成功', data={"order_id": order.id})
def save_orders():
# 获取数据
user_id = g.user_id
req_dict = request.get_json()
print(req_dict)
house_id = req_dict.get('house_id')
start_date_str = req_dict.get('start_date')
end_date_str = req_dict.get('end_date')
# 数据校验
# 数据完整性
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg=u'数据不完整')
# 校验时间格式
try:
start_date = datetime.strptime(start_date_str, '%Y-%m-%d')
end_date = datetime.strptime(end_date_str, '%Y-%m-%d')
assert start_date <= end_date
# 提取入住天数
days = (end_date - start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg=u'时间格式错误')
# 校验房屋
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'房屋信息查询失败')
if house is None:
return jsonify(errno=RET.NODATA, errmsg=u'房屋不存在')
# 校验入住时间冲突
try:
order_count = Order.query.filter(start_date < Order.end_date,
house_id == house_id,
end_date > Order.begin_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'入住时间校验出错')
if order_count > 0:
return jsonify(errno=RET.DATAEXIST, errmsg=u'订单冲突')
# 校验房主和下单者
if house.user_id == user_id:
return jsonify(errno=RET.ROLEERR, errmsg=u'房主不允许下单')
# 业务处理: 保存订单
order = Order()
order.user_id = user_id
order.house_id = house_id
order.begin_date = start_date
order.end_date = end_date
order.days = days
order.house_price = house.price
order.amount = days * house.price
try:
db.session.add(order)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'订单保存失败')
# 返回响应
return jsonify(errno=RET.OK, errmsg=u'下单成功')
def save_order_info():
"""
创建房屋预定订单：
1.接收参数（房屋id，起始时间，结束时间）并进行参数验证
2.根据房屋id查询房屋的信息（如果查不到，说明房屋不存在）
3.创建Order对象并保存订单信息
4.将订单信息添加进数据库
5.返回应答，订单创建成功
"""
# 1.接收参数（房屋id，起始时间，结束时间）并进行参数验证
req_dict = request.json
house_id = req_dict.get("house_id")
start_date = req_dict.get("start_date")
end_date = req_dict.get("end_date")
if not all([house_id, start_date, end_date]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
try:
start_date = datetime.strptime(start_date, "%Y-%m-%d")
end_date = datetime.strptime(end_date, "%Y-%m-%d")
assert start_date < end_date, Exception("搜索起始时间大于结束时间")
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 2.根据房屋id查询房屋的信息（如果查不到，说明房屋不存在）
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询房屋信息失败")
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋不存在")
# 判断此房屋是否已被预定
try:
conflict_count = Order.query.filter(
end_date > Order.begin_date, start_date < Order.end_date,
Order.house_id == house_id).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取冲突订单信息失败")
if conflict_count > 0:
return jsonify(errno=RET.DATAERR, errmsg="房屋已被预定")
# 3.创建Order对象并保存订单信息
order = Order()
days = (end_date - start_date).days # timedelta
order.user_id = g.user_id
order.house_id = house_id
order.begin_date = start_date
order.end_date = end_date
order.days = days
order.house_price = house.price
order.amount = days * house.price
# 房屋预定量+1
house.order_count += 1
# 4.将订单信息添加进数据库
try:
db.session.add(order)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存订单信息失败")
# 5.返回应答，订单创建成功
return jsonify(errno=RET.OK, errmsg="房屋预定成功")
def save_order():
"""保存订单"""
user_id = g.user_id
order_data = request.get_json()
if not order_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
house_id = order_data.get("house_id")
start_date_str = order_data.get("start_date")
end_date_str = order_data.get("end_date")
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 校验日期格式
try:
start_date = datetime.datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.datetime.strptime(end_date_str, "%Y-%m-%d")
assert start_date <= end_date
# 计算预订的天数
days = (end_date - start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 查询房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取信息失败")
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋不存在")
# 预定的房屋是否是房东自己的
if user_id == house.user_id:
return jsonify(errno=RET.ROLEERR, errmsg="不能预定自己的房屋")
# 确保用户预订的时间内，房屋没有被人下单
try:
count = Order.query.filter(Order.house_id == house_id,
Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="检查出错，请稍后重试")
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg="房屋已被预定")
amount = days * house.price
order = Order(house_id=house_id,
user_id=user_id,
begin_date=start_date,
end_date=end_date,
days=days,
house_price=house.price,
amount=amount)
try:
db.session.add(order)
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={"order_id": order.id})
def save_order():
user_id=g.user_id
#获取参数
order_data=request.get_json()
if not order_data:
return jsonify(errno=RET.PARAMERR,errmsg="参数错误")
house_id = order_data.get("house_id") # 预订的房屋编号
start_date_str = order_data.get("start_date") # 预订的起始时间
end_date_str = order_data.get("end_date") # 预订的结束时间
# print(start_date_str,end_date_str)
#参数检查
if not all([house_id,start_date_str,end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
#日期格式检查
try:
#将请求的时间参数字符串转换为datetime类型
start_date=datetime.datetime.strptime(start_date_str,"%Y-%m-%d")
end_date=datetime.datetime.strptime(end_date_str,"%Y-%m-%d")
assert start_date<=end_date
#计算预计的天数
days=(end_date-start_date).days+1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="日期格式错误")
#查询房屋是否存在
try:
house=House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取房屋信息失败")
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋不存在")
#预定的房屋是否是房东自己的
if user_id==house.user_id:
return jsonify(errno=RET.ROLEERR, errmsg="不能预订自己的房屋")
#确保用户预定的时间内，房屋没有别人下单
try:
#查询时间冲突的订单数
count=Order.query.filter(Order.house_id==house_id,Order.begin_date<=end_date,Order.end_date>=start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="检查出错，请稍候重试")
if count>0:
return jsonify(errno=RET.DATAERR, errmsg="订单冲突")
#订单总额
amount=days*house.price
#保存订单数据
order=Order(
house_id=house_id,
user_id=user_id,
begin_date=start_date,
end_date=end_date,
days=days,
house_price=house.price,
amount=amount,
)
#提交数据
try:
db.session.add(order)
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={'order_id':order.id})
def add_order():
"""
下单
1. 获取参数
2. 校验参数
3. 查询指定房屋是否存在
4. 判断当前房屋的房主是否是登录用户
5. 查询当前预订时间是否存在冲突
6. 生成订单模型，进行下单
7. 返回下单结果
:return:
"""
# 获取到当前用户的id
user_id = g.user_id
# 1. 获取到传入的参数
params = request.get_json()
house_id = params.get('house_id')
start_date_str = params.get('start_date')
end_date_str = params.get('end_date')
# 2. 校验参数
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
try:
start_date = datetime.datetime.strptime(start_date_str, '%Y-%m-%d')
end_date = datetime.datetime.strptime(end_date_str, '%Y-%m-%d')
assert start_date < end_date, Exception("开始日期大于结束日期")
# 计算入住天数
days = (end_date - start_date).days
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 3. 查询指定房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据查询错误")
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋不存在")
# 4. 判断当前房屋的房主是否是当前用户，如果当前用户是房东，不能预订
if house.user_id == user_id:
return jsonify(errno=RET.ROLEERR, errmsg="不能预订自已的房屋")
# 5. 查询该房屋是否有冲突的订单
try:
filters = [Order.house_id == house_id, Order.begin_date < end_date, Order.end_date > start_date]
count = Order.query.filter(*filters).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据查询错误")
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg="该房屋已被预订")
# 6. 生成订单模型，进行下单
order = Order()
order.user_id = user_id
order.house_id = house_id
order.begin_date = start_date
order.end_date = end_date
order.days = days
order.house_price = house.price
order.amount = days * house.price
try:
db.session.add(order)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="生成订单失败")
# 7. 返回下单结果
return jsonify(errno=RET.OK, errmsg="OK", data={"order_id": order.id})
def create_order():
"""创建、提交订单
0.判断用户是否登录
1.接受参数，house_id, 入住时间和离开时间
2.校验参数，判断入住时间和离开是否符合逻辑，校验房屋是否存在
3.判断当前房屋有没有被预定
4.创建订单模型对象，并存储订单数据
5.保存到数据库
6.响应结果
"""
# 1.接受参数，house_id, 入住时间和离开时间
json_dict = request.json
house_id = json_dict.get('house_id')
start_date_str = json_dict.get('start_date')
end_date_str = json_dict.get('end_date')
# 判断是否缺少参数
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
# 2.校验参数，判断入住时间和离开是否符合逻辑，校验房屋是否存在
try:
start_date = datetime.datetime.strptime(start_date_str, '%Y-%m-%d')
end_date = datetime.datetime.strptime(end_date_str, '%Y-%m-%d')
# 自己校验入住时间是否小于离开的时间
if start_date and end_date:
# 断言：入住时间一定小于离开时间，如果不满足，就抛出异常
assert start_date < end_date, Exception('入住时间有误')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='入住时间有误')
# 判断房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询房屋数据失败')
if not house:
return jsonify(errno=RET.NODATA, errmsg='房屋不存在')
# 3.判断当前房屋有没有被预定
try:
conflict_orders = Order.query.filter(
Order.house_id == house_id, end_date > Order.begin_date,
start_date < Order.end_date).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询冲突订单失败')
# 如果有值，说明要预订的房屋在该时间节点，已经在订单中，说明被预定
if conflict_orders:
return jsonify(errno=RET.DATAERR, errmsg='房屋已被预订')
# 4.创建订单模型对象，并存储订单数据
days = (end_date - start_date).days # 计算时间段之间的天数
order = Order()
order.user_id = g.user_id
order.house_id = house_id
order.begin_date = start_date
order.end_date = end_date
order.days = days
order.house_price = house.price
order.amount = house.price * days
# 5.保存到数据库
try:
db.session.add(order)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存订单数据失败')
# 6.响应结果
return jsonify(errno=RET.OK, errmsg='OK')
def save_order():
"""保存订单"""
# 获取用户id
user_id = g.user_id
# 获取参数
order_data = request.get_json()
if not order_data:
return jsonify(error_code=RET.PARAMERR, errmsg="参数错误")
house_id = order_data.get("house_id") # 预定的房屋编号
start_data_str = order_data.get("start_date") # 预定的起始时间
end_data_str = order_data.get("end_date") # 预定的结束时间
# 参数校验
if not all([house_id, start_data_str, end_data_str]):
return jsonify(error_code=RET.PARAMERR, errmsg="参数不完整")
# 日期格式检验
try:
# 将请求的时间参数字符串转换为datetime类型
start_date = datetime.strptime(start_data_str, "%Y-%m-%d")
end_date = datetime.strptime(end_data_str, "%Y-%m-%d")
assert start_date <= end_date
# 计算预定的天数
days = (end_date - start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(error_code=RET.PARAMERR, errmsg="日期格式错误")
# 查询房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(error_code=RET.DBERR, errmsg="获取房屋信息失败")
if not house:
return jsonify(error_code=RET.NODATA, errmsg="房屋不存在")
# 预定的房屋是否是房东自己的
if user_id == house.user_id:
return jsonify(error_code=RET.ROLEERR, errmsg="不能预定自己的房屋")
# 确保用户预定的时间内，房屋没有被别人下单
try:
# 查询时间冲突的订单
count = Order.query.filter(Order.house_id == house.id,
Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(error_code=RET.DBERR, errmsg="检查出错，请稍后再试")
if count > 0:
return jsonify(error_code=RET.DATAERR, errmsg="房屋已被预定")
# 订单总额
amount = days * house.price
# 保存订单数据
order = Order()
order.house_id = house_id
order.user_id = user_id
order.begin_date = start_date
order.end_date = end_date
order.days = days
order.house_price = house.price
order.amount = amount
try:
db.session.add(order)
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="ok", data={"order_id": order.id})
def save_order():
"""保存订单"""
user_id = g.user_id
# 获取参数
order_data = request.get_json()
if not order_data:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
house_id = order_data.get("house_id")
start_date_str = order_data.get("start_date")
end_date_str = order_data.get("end_date")
# 校验参数
if not all([house_id, start_date_str, end_date_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 日期格式检查
try:
# 将请求的时间参数字符串转换为datetime类型
start_date = datetime.datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.datetime.strptime(end_date_str, "%Y-%m-%d")
assert start_date <= end_date
# 计算预订的天数
days = (end_date - start_date).days + 1 # datetime.timedelta
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="日期格式错误")
# 查询房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errmo=RET.DBERR, errmsg="获取房屋信息失败")
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋不存在")
# 预订的房屋是否是房东自己的
if user_id == house.user_id:
return jsonify(errno=RET.ROLEERR, errmsg="不能预订自己的房屋")
# 确保用户预订的时间内，房屋没有被下单
try:
# 查询时间冲突的订单数
# select count(*) from order where ....
count = Order.query.filter(Order.house_id == house_id,
Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="检查出错，请稍后重试")
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg="房屋已被预订")
# 订单总额
amount = days * house.price
# 保存订单数据
order = Order(house_id=house_id,
user_id=user_id,
begin_date=start_date,
end_date=end_date,
days=days,
house_price=house.price,
amount=amount)
try:
db.session.add(order)
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={"order_id": order.id})
def save_order():
'''保存订单'''
user_id = g.user_id
# 获取参数
request_json = request.get_json()
print('获取request_json')
if not request_json:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
house_id = request_json.get('house_id')
start_date = request_json.get('start_date')
end_date = request_json.get('end_date')
if not all([house_id, start_date, end_date]):
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 日期格式检查
try:
# 将请求的时间参数字符串转换为datetime类型
start_date = datetime.datetime.strptime(start_date, '%Y-%m-%d')
end_date = datetime.datetime.strptime(end_date, '%Y-%m-%d')
assert start_date <= end_date
# 机算预定天数
days = (end_date - start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='日期格式错误')
# 查询房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='获取房屋信息失败')
if not house:
return jsonify(errno=RET.DBERR, errmsg='房屋不存在')
# 预定的房屋是否是房东自己的
if user_id == house.user_id:
return jsonify(errno=RET.ROLEERR, errmsg='不能预定自己的房屋')
# 确保用户预定的时间内，房屋没有被别人下单
try:
# 查询时间冲突的订单数
count = Order.query.filter(Order.house_id == house_id,
Order.begin_date <= end_date,
Order.end_date >= start_date).count()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='检查出错,请稍后重试')
if count > 0:
return jsonify(errno=RET.DATAERR, errmsg='房屋已经被预定了')
# 订单金额
amount = days * house.price
# 保存订单数据
order = Order(house_id=house_id,
user_id=user_id,
begin_date=start_date,
end_date=end_date,
days=days,
house_price=house.price,
amount=amount)
try:
db.session.add(order)
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={'order_id': order.id})