Exemplo n.º 1
0
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')
Exemplo n.º 2
0
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')
Exemplo n.º 3
0
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="创建成功")
Exemplo n.º 4
0
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
Exemplo n.º 5
0
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})
Exemplo n.º 6
0
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})
Exemplo n.º 7
0
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})
Exemplo n.º 8
0
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})
Exemplo n.º 9
0
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})
Exemplo n.º 10
0
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})
Exemplo n.º 11
0
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')
Exemplo n.º 12
0
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'下单成功')
Exemplo n.º 13
0
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})
Exemplo n.º 14
0
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})
Exemplo n.º 15
0
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})
Exemplo n.º 16
0
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})
Exemplo n.º 17
0
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})
Exemplo n.º 18
0
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="房屋预定成功")
Exemplo n.º 19
0
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'创建订单成功')
Exemplo n.º 20
0
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="订单保存成功")
Exemplo n.º 21
0
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')