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')