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 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 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 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 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():
"""保存订单"""
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") # 预定的起始shijian
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
print(days)
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.user_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="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():
"""保存订单"""
# 一. 获取数据
# 获取用户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 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_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_orders():
"""保存订单"""
#获取user_id
user_id = g.user_id
#获取json数据
req_data = request.get_json()
#判断获取结果
if not req_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
#获取详细参数--house_id,start_date_str,end_date_str
house_id = req_data.get('house_id')
start_date_str = req_data.get('start_date')
end_date_str = req_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 end_date >= start_date
days = (end_date - start_date).days + 1
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg='日期格式错误')
#查询房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询房屋数据失败')
#确保房东不能预订自己的房屋
if house.user_id == user_id:
return jsonify(errno=RET.REQERR, 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 = house.price * days
#构建模型类，修改订单状态为待评论，添加房屋基本信息
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='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 save_order():
"""
保存订单
:return:
"""
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 = (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,
Order.status != 'REJECTED').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='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
# 获取参数
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 = 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="OK", data={"order_id": order.id})
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 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 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 create_order():
"""添加订单：
0.登录校验
1.获取请求参数,useri_id
2.日期字符串转为日期对象，查询订单时间段是否和已有订单时间段冲突
3.计算时间
4.添加订单
5.返回响应结果
"""
# 1.获取参数{u'house_id': u'4', u'start_date': u'2018-04-10', u'end_date': u'2018-04-13'}
json_dict=request.json
house_id=json_dict.get('house_id')
start_date = json_dict.get('start_date')
end_date = json_dict.get('end_date')
#校验数据
if not all([house_id,start_date,end_date]):
return jsonify(re_code=RET.PARAMERR,msg='参数有误')
# 2.查询订单时间段是否和已有订单时间段冲突
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='房屋已被预订')
# 3.计算时间
days=(end_date-start_date).days
# 4.创建订单模型类
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='保存订单失败')
# 5.返回响应结果
return jsonify(re_code=RET.OK,msg='ok')