def get(self, item_id):
item = ItemModel.find_by_id(item_id)
if item is None:
return {'status': False, 'message': 'Item not found', 'data': None}
product_id = item.json()['product_id']
product = ProductModel.find_by_id(product_id)
promotion_items = PromotionModel.find_promotion_items(product_id)
sold_price = product.json()['price']
if promotion_items:
for p_item in promotion_items:
sold_price -= (p_item.json()['discount'] /
100) * product.json()['price']
p_item.used_items += 1
p_item.save_to_db()
order = OrderModel(item_id, float("{:.2f}".format(sold_price)))
order.save_to_db()
item.delete_from_db()
return {
'status': True,
'message': 'A item has been sold.',
'data': order.json()
}
def post(self):
status = request.json.get('status')
objectID = request.json.get('objectID')
weight = request.json.get('weight')
profit = request.json.get('profit')
location = request.json.get('location')
address = request.json.get('address')
sequence = request.json.get('sequence')
UserID = request.json.get('UserID')
if objectID is None:
abort(400)
order = OrderModel()
order.status = status
order.objectID = objectID
order.weight = weight
order.profit = profit
order.location = location
order.address = address
order.sequence = sequence
order.UserID = UserID
db.session.add(order)
db.session.commit()
response = jsonify({'id': order.id})
response.status_code = 201
return response
def post(cls):
"""
Expect a token and a list of item ids from the request body.
Construct an order and talk to the Strip API to make a charge.
:return:
"""
data = request.get_json() # token + list of item ids
items = []
item_id_quantities = Counter(data["item_ids"])
#iterate over items and retrieve them from the database
for _id, count in item_id_quantities.most_common():
item = ItemModel.find_by_id(_id)
if not item:
return {"message": gettext("order_item_by_id_not_found").format(_id)}, 404
items.append(ItemsInOrder(item_id=_id, quantity=count))
order = OrderModel(items=items, status="pending")
order.save_to_db() # this does not submit to Stripe
try:
order.set_status("failed")
order.charge_with_stripe(data["token"])
order.set_status("complete")
return order_schema.dump(order), 200
except(error.CardError, error.RateLimitError, error.InvalidRequestError, error.AuthenticationError,
error.APIConnectionError, error.StripeError) as e:
return e.json_body, e.http_status
except Exception as e:
print(e)
return {"message": gettext("order_error")}, 500
def post(cls):
"""
Expect a token and a list of item ids from the request body.
Construct an order and talk to the Strip API to make a charge.
"""
data = request.get_json(
) # token + list of item ids [1, 2, 4, 4, 5, 2, 1, 1, 4]
items = []
item_id_quantities = Counter(data["item_ids"])
# Iterate over items and retrieve them from the database
for _id, count in item_id_quantities.most_common(
): # [(1,3),(2,2),(4,3),(5,1)]
item = ItemModel.find_by_id(_id)
if not item:
return {"message": "Item {} Not Found.".format(_id)}, 404
items.append(ItemsInOrder(item_id=_id, quantity=count))
order = OrderModel(items=items, status="pending")
order.save_database() # this does not submit to Stripe
try:
order.set_status(
"failed") # assume the order would fail until it's completed
order.charge_stripe(data["token"])
order.set_status("complete") # charge succeeded
except stripe.error.CardError as e:
# Since it's a decline, stripe.error.CardError will be caught
print('Status is: %s' % e.http_status)
print('Type is: %s' % e.error.type)
print('Code is: %s' % e.error.code)
# param is '' in this case
print('Param is: %s' % e.error.param)
print('Message is: %s' % e.error.message)
return {"message": e.error.message}, e.http_status
except stripe.error.RateLimitError as e:
# Too many requests made to the API too quickly
return {"message": e.error.message}, e.http_status
except stripe.error.InvalidRequestError as e:
# Invalid parameters were supplied to Stripe's API
return {"message": e.error.message}, e.http_status
except stripe.error.AuthenticationError as e:
# Authentication with Stripe's API failed
# (maybe you changed API keys recently)
return {"message": e.error.message}, e.http_status
except stripe.error.APIConnectionError as e:
# Network communication with Stripe failed
return {"message": e.error.message}, e.http_status
except stripe.error.StripeError as e:
# Display a very generic error to the user, and maybe send
# yourself an email
return {"message": e.error.message}, e.http_status
except Exception as e:
# Something else happened, completely unrelated to Stripe
return {"message": e.error.message}, e.http_status
return order_schema.dump(order), 200
def buynow(self, request):
"""立即购买"""
self.response_["type"] = self.RESPONSE_TYPE_JSON
id = request.GET.get("id")
num = request.GET.get("num")
try:
customer = self.context["customer"]
product = ProductModel.objects.get(id=id)
newOrder = OrderModel(customer=customer)
newOrder.save()
newOrder.products.create(product=product, amount=num)
except Exception as e:
self.context = {
"code": 4,
"msg": "下单失败",
"data": {
"pid": id,
"error": str(e)
}
}
else:
self.context = {
"code": 200,
"msg": "下单成功",
"data": {
"oid": newOrder.id
}
}
def post(cls):
"""
Expect a token and a list of item ids from the request body.
Construct an order and talk to the Strip API to make a charge.
"""
data = request.get_json(
) # token + list of item ids [1, 2, 3, 5, 5, 5]
items = []
item_id_quantities = Counter(data["item_ids"])
# [(5, 3), (3, 1), (2, 1)]
for _id, count in item_id_quantities.most_common(
): #most common give u how many items in the order they happen
item = ItemModel.find_by_id(_id)
if not item:
return {
"message":
gettext("order_item_by_id_not_found").format(_id)
}, 404
# items.append(item)
items.append(ItemsInOrder(item_id=_id, quantity=count))
order = OrderModel(items=items, status="pending")
order.save_to_db() #THIS DOES NOT SUBMIT TO STRIPE
order.set_status(
"failed") # assume the order would fail until it's completed
order.charge_with_stripe(data["token"])
order.set_status("complete") # charge succeeded
return order_schema.dump(order), 200
def post(cls):
"""
Expect a token and a list of item ids from the request body
Construct an order and talk to the Stripe API to make a charge
"""
data = request.get_json() # token + list of item ids
items = []
item_id_quantities = Counter(data["item_idss"])
for _id, count in item_id_quantities.most_common():
item = ItemModel.find_by_id(_id)
if not item:
return {
"message":
gettext("order_item_by_id_not_found").format(_id)
}, 404
items.append(ItemsInOrder(item_id=_id, quantity=count))
order = OrderModel(items=items, status="pending")
order.save_to_db()
order.set_status("failed")
order.charge_with_stripe(data["token"])
order.set_status("complete")
return order_schema.dump(order)
def post(cls):
"""
Expect a token and a list of item ids from the request body.
Construct an order and talk to the Strip API to make a charge.
"""
data = request.get_json(
) # token + list of item ids [1, 2, 3, 5, 5, 5]
items = []
item_id_quantities = Counter(data["item_ids"])
# Iterate over items and retrieve them from the database
for _id, count in item_id_quantities.most_common(
): # -> [(5,3), (3,1), (2,1), (1,1)]
item = ItemModel.find_by_id(_id)
if not item:
return {
"message":
gettext("order_item_by_id_not_found").format(_id)
}, 404
items.append(ItemsInOrder(item_id=_id, quantity=count))
order = OrderModel(items=items, status="pending")
order.save_to_db() # this does not submit to Stripe
order.set_status("failed")
order.charge_with_stripe(data['token'])
order.set_status("completed")
return order_schema.dump(order)
def post(self, authorization, products):
# parse the token
token = parse_jwt(authorization)
if not token:
return {
'success': False,
'messages': ['INVALID_TOKEN']
}, 401
# construct a new order
new_order = OrderModel(
extract_uuid(token),
products,
'2017-10-10 20:00:00',
False
)
# add the order to the database
OrderModel.save_to_db(new_order)
return {
'success': True,
'data': {
'fulfilled': new_order.fulfilled,
'id': new_order.id,
'products': new_order.products
}
}, 201
def post(cls):
"""Expect a token and a list of item ids from the request body.
Construct an order and talk to the Strip API to make a charge."""
data = request.get_json() # token ,item_ids [1, 3, 3, 5, 5, 5]
items = []
item_id_quantities = Counter(data["item_ids"])
for _id, count in item_id_quantities.most_common(
): # [(5,3),(3,2),(1,1)]
item = ItemModel.find_by_id(_id)
if not item:
return {
"message":
gettext("order_item_by_id_not_found").format(_id)
}, 404
"""ItemsInOrder get item_id and quantity, however
order_id will be set later on,
when items is passed into OrderModel, because back_populates="order"
it goes over to order column of ItemsInOrder table,
and set order_id for each of those item in OrderModel
to be the order to which you have added those items"""
items.append(ItemsInOrder(item_id=_id, quantity=count))
# items is a list of ItemsInOrder obj
order = OrderModel(items=items,
status="pending") # pending until send to Stripe
order.save_to_db() # this does not submit to Stripe
try:
order.set_status(
"failed") # assume the order would fail until it's completed
order.charge_with_stripe(data["token"])
order.set_status("complete") # charge succeeded
return order_schema.dump(order), 200
# the following error handling is advised by Stripe, although the handling implementations are identical,
# we choose to specify them separately just to give the students a better idea what we can expect
except error.CardError as e:
# Since it's a decline, stripe.error.CardError will be caught
return e.json_body, e.http_status
except error.RateLimitError as e:
# Too many requests made to the API too quickly
return e.json_body, e.http_status
except error.InvalidRequestError as e:
# Invalid parameters were supplied to Stripe's API
return e.json_body, e.http_status
except error.AuthenticationError as e:
# Authentication with Stripe's API failed
# (maybe you changed API keys recently)
return e.json_body, e.http_status
except error.APIConnectionError as e:
# Network communication with Stripe failed
return e.json_body, e.http_status
except error.StripeError as e:
# Display a very generic error to the user, and maybe send
# yourself an email
return e.json_body, e.http_status
except Exception as e:
# Something else happened, completely unrelated to Stripe
print(e)
return {"message": gettext("order_error")}, 500
def test_get_product(self):
order = OrderModel.get(1)
assert order != None
orders = OrderModel.list()
assert len(orders) == 1
assert type(orders) == type([])
def get(self, rfid):
user = UserModel.find_by_rfid(rfid)
if user:
current_order = int(user.current_order)
recipe = RecipeModel.find_by_id(current_order)
ingredients = RecipeModel.find_ingredients(current_order)
durations = [0, 0, 0, 0]
for ingredient in ingredients:
durations[ingredient[0]['pump'] - 1] = ingredient[0]['portion']
timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
order = OrderModel(user.id, user.current_order, timestamp)
order.save_to_db()
return {"durations": durations}
awaiting = UserCardRegistrationModel.awaiting_for_card
if awaiting:
if UserModel.find_by_username(awaiting):
UserModel.update_card(awaiting, rfid)
return {"durations": [0, 0, 0, 0]}
else:
return {"message": "No such user"}
else:
return {"durations": [0, 0, 0, 0]}
def get(cls):
uid = get_jwt_identity()
orders = []
if StoreModel.find_by_id(uid):
for order in OrderModel.find_all():
if order.status == 'pending':
items = fetching_order(order.order_items)
message = order.message
orders.append({
'id': order.id,
'status': order.status,
'items': items,
'message': message
})
return orders, 200
elif CustomerModel.find_by_id(uid):
for order in OrderModel.find_customer_completed_orders(
customer_id=uid):
items = fetching_order(order.order_items)
message = order.message
orders.append({
'id': order.id,
'items': items,
'message': message
})
return orders, 200
return 401
def get(self, name):
a = []
filtered_order = OrderModel.find_by_item_name(name)
for item in filtered_order:
order_id = item.order_id
fil_order = OrderModel.find_by_order_id(order_id).first()
a.append(fil_order.json())
return a
def post(cls):
"""
Expect a token and a list of item ids from the request body.
Construct an order an talk to the Stripe API to make a charge.
"""
data = request.get_json() # token + list of item ids
items = []
item_id_quantities = Counter(
data['item_ids']
) # you pass a list to the Counter and it will count for you
# Iterate over items and retrieve them from the db
for _id, count in item_id_quantities.most_common():
item = ItemModel.find_by_id(_id)
if not item:
return {
'message':
gettext('order_item_by_id_not_found').format(_id)
}, 404
items.append(ItemsInOrder(item_id=_id, quantity=count))
order = OrderModel(items=items, status='pending')
order.save_to_db()
# submit to Stripe
try:
order.set_status(
"failed") # assume the order would fail until it's completed
order.charge_with_stripe(data["token"])
order.set_status("complete") # charge succeeded
return order_schema.dump(order), 200
# the following error handling is advised by Stripe, although the handling implementations are identical,
# we choose to specify them separately just to give the students a better idea what we can expect
except error.CardError as e:
# Since it's a decline, stripe.error.CardError will be caught
return e.json_body, e.http_status
except error.RateLimitError as e:
# Too many requests made to the API too quickly
return e.json_body, e.http_status
except error.InvalidRequestError as e:
# Invalid parameters were supplied to Stripe's API
return e.json_body, e.http_status
except error.AuthenticationError as e:
# Authentication with Stripe's API failed
# (maybe you changed API keys recently)
return e.json_body, e.http_status
except error.APIConnectionError as e:
# Network communication with Stripe failed
return e.json_body, e.http_status
except error.StripeError as e:
# Display a very generic error to the user, and maybe send
# yourself an email
return e.json_body, e.http_status
except Exception as e:
# Something else happened, completely unrelated to Stripe
print(e)
return {"message": gettext("order_error")}, 500
def create_order(self, order_entity):
order = OrderModel.get_by_main_order_id(self.db, order_entity.id)
if order:
# callback 订单已存在
Log.info('order exist')
return order
order = OrderModel.new_order(self.db, order_entity)
return order
def post(self, username):
data = Order.parser.parse_args()
order = OrderModel(username, **data)
try:
order.save_to_db()
except:
# Internal Server Error
return {"message": "An error occured inserting the item."}, 500
return {"message": "Success"}
def create_order(self, order_entity):
order = OrderModel.get_by_main_order_id(self.db, order_entity.id)
if order:
# callback 订单已存在
Log.info('order exist')
return order
order = OrderModel.new_order(self.db, order_entity)
return order
def reset_order_status(self, order_entity):
order = OrderModel.get_by_main_order_id(self.db, order_entity.id)
if not order:
raise JsonException(1, 'order not exist')
pre_status = order.status
OrderModel.change_order_status_by_main_order_id(self.db, order_entity.id, 0)
OrderHistoryModel.set_order_status_by_server(self.db, order, pre_status, 0)
def post(self):
order_id = self.get_argument('order_id', None)
if not order_id:
raise JsonException(-1, '缺少order_id')
try:
OrderModel.change_order_pay_by_main_order_id(self.db, order_id)
self.finish_json()
except Exception, e:
raise JsonException(-1, e.message)
def createOrder(data):
order = OrderModel()
order.productId = data['productId']
order.productName = data['productName']
order.productAmount = data['productAmount']
order.productPrice = data['productPrice']
order.deliveryAddress = data['deliveryAddress']
order.deliveryState = data['deliveryState']
order.save()
def post(self):
data = OrderPost.parser.parse_args()
order = OrderModel(**data)
try:
order.save_to_db()
except:
return {'message': 'An error occured inserting the order'}, 500
return order.json(), 201
def reset_order_status(self, order_entity):
order = OrderModel.get_by_main_order_id(self.db, order_entity.id)
if not order:
raise JsonException(1, 'order not exist')
pre_status = order.status
OrderModel.change_order_status_by_main_order_id(
self.db, order_entity.id, 0)
OrderHistoryModel.set_order_status_by_server(self.db, order,
pre_status, 0)
def post(self):
data = Order.parser.parse_args()
order = OrderModel(**data)
try:
order.save_to_db()
except:
return {"message": "An error occurred inserting the item."}, 500
return order.json(), 201
def post(self, product_id):
data = RequestedOrder.parser.parse_args()
if OrderModel.search_requested_from_database_by_id(product_id):
return {"message": "This product has been ordered"}, 400
data.update({"renter_national_id": None, "accepted": None})
OrderModel.add_to_database(OrderModel(**data))
return {
"message": "Order has been successfully delivered to the lender"
}, 201
def get(self):
"""
Devuelve la lista de pedidos hechos por un usuario, si es vendedor, la lista de pedidos recibidos.
"""
if current_identity.user_type == user_types['vendor']:
return [
order.json()
for order in OrderModel.get_by_vendor(current_identity.id)
]
return [
order.json()
for order in OrderModel.get_by_customer(current_identity.id)
]
def create_order(session, submit_order):
order = OrderModel.get_by_main_order_id(session, submit_order.id)
if order:
# callback 订单已存在
Log.info('order exist')
return order
order = OrderModel.new_order(session, submit_order)
if order:
return order
else:
# callback 创建失败
pass
def post(cls):
"""
Expects a token and a list of item ids from the request body.
Constructs an order and talks to the Stripe API to make a charge.
"""
data = request.get_json()
items = []
item_id_quantities = Counter(data["items_id"])
for _id, count in item_id_quantities.most_common():
item = ItemModel.find_by_id(_id)
if not item:
return {"message": f"Item {_id} Not Found."}, 404
items.append(ItemsInOrder(item_id=_id, quantity=count))
order = OrderModel(items=items, status="pending")
order.save_to_db()
try:
order.set_status("payment failed")
order.charge_with_stripe(data["token"])
order.set_status("payment completed")
return orderSchema.dump(order)
# the following error handling is advised by Stripe, although the handling implementations are identical,
# we choose to specify them separately just to give the students a better idea what we can expect
except error.CardError as e:
# Since it's a decline, stripe.error.CardError will be caught
return e.json_body, e.http_status
except error.RateLimitError as e:
# Too many requests made to the API too quickly
return e.json_body, e.http_status
except error.InvalidRequestError as e:
# Invalid parameters were supplied to Stripe's API
return e.json_body, e.http_status
except error.AuthenticationError as e:
# Authentication with Stripe's API failed
# (maybe you changed API keys recently)
return e.json_body, e.http_status
except error.APIConnectionError as e:
# Network communication with Stripe failed
return e.json_body, e.http_status
except error.StripeError as e:
# Display a very generic error to the user, and maybe send
# yourself an email
return e.json_body, e.http_status
except Exception as e:
# Something else happened, completely unrelated to Stripe
print(e)
return {"message": "Order Error"}, 500
def post(self, product_id):
data = ResponsedOrder.parser.parse_args()
if not data["accepted"]:
return {"message": "Your request has been denied"}, 400
data.update({"notified": False, "expired": False})
OrderModel.update_order(data)
ProductModel.search_from_database_by_id(
data["product_id"]).update_status(data["accepted"])
return {"message": "The lender has been accepted your request"}, 200
def get(self, renter_id):
return {
"expiring": [
expiring_order.json()
for expiring_order in OrderModel.get_expiring_orders(renter_id)
]
}, 200
def get(self, lender_id):
return {
"pending_requests": [
request.json()
for request in OrderModel.get_pending_requests(lender_id)
]
}, 200
def get(self):
merchant_id = self.current_user.merchant_id
total = OrderModel.get_waiting_orders_count(self.db, merchant_id)
self.finish_json(result={
'total': total,
})
def put(self, _id):
claims = get_jwt_claims()
if not claims['is_admin']:
return {'message': 'Admin privilege required.'}, 401
parser = reqparse.RequestParser()
parser.add_argument('food_id',
type=list,
required=True,
location='json',
help="every order need a list of food id!")
data = Order.parser.parse_args()
order = OrderModel.find_by_id(_id)
if order:
foods = [
FoodModel.find_by_id(food).json() for food in data['food_id']
]
total_price = sum([food['price'] for food in foods])
order.total_price = total_price
order.updated_at = datetime.now()
else:
return {'message': 'Order not found'}, 404
try:
order.save_to_db()
except:
return {"message": "An error occurred inserting the food."}, 500
return order.json(), 201
def send_order_sms(self, merchant_id, hotel_name, order_id, confirm_type):
Log.info(u">>> send sms to merchant {} hotel {} order_id {} confirm type {}".format(merchant_id, hotel_name, order_id, confirm_type))
order = OrderModel.get_by_id(self.session, order_id)
breakfast_str = u'含早' if order.get_has_breakfast() else u'无早'
customers = json.loads(order.customer_info)
customer_str = " ".join([customer['name'] for customer in customers])
if confirm_type == OrderModel.CONFIRM_TYPE_AUTO:
content = u"尊敬的用户您好，系统收到编号{}自动确认订单：{}，房型：{}，入离日期：{}至{}( {}晚 )，入住人：{}，总价：{}，{}。订单号：{}，请及时关注。客服联系电话：4006103330".format(merchant_id, hotel_name, order.roomtype_name, order.checkin_date, order.checkout_date, order.get_stay_days(), customer_str, order.total_price / 100, breakfast_str, order_id)
elif confirm_type == OrderModel.CONFIRM_TYPE_MANUAL:
content = u"尊敬的用户您好，系统收到编号{}待确认订单：{}，房型：{}，入离日期：{}至{}( {}晚 )，入住人：{}，总价：{}，{}。订单号：{}，请尽快处理。客服联系电话：4006103330".format(merchant_id, hotel_name, order.roomtype_name, order.checkin_date, order.checkout_date, order.get_stay_days(), customer_str, order.total_price / 100, breakfast_str, order_id)
send_sms_to_service(merchant_id, content)
user =UserModel.get_user_by_merchantid_username(self.session, merchant_id, 'admin')
if not user:
Log.info("send sms no user(order {})".format(order_id))
return
phone = user.mobile
if not phone:
Log.info("send sms no phone(order {})".format(order_id))
return
Log.info(">> send sms to {}".format(phone))
Log.info(u">> sms content: {}".format(content))
send_sms([phone], content)
def get(self):
merchant_id = self.current_user.merchant_id
total = OrderModel.get_waiting_orders_count(self.db, merchant_id, self.current_user.hotel_id)
self.finish_json(result={
'total': total,
})
def get(self, order_id):
merchant_id = self.current_user.merchant_id
order = OrderModel.get_by_merchant_and_id(self.db, merchant_id, order_id, self.current_user.hotel_id)
self.finish_json(result={
'order': order.todict() if order else None,
})
def post(self):
order_id = self.get_argument('order_id', None)
status = self.get_argument('status', None)
if not order_id:
raise JsonException(-1, 'params : id not exists')
if not status or int(status) not in [300, 500]:
raise JsonException(-1, 'params: status is not validate')
order = OrderModel.get_by_main_order_id(self.db, order_id)
if not order:
raise JsonException(1, 'order not exist')
pre_status = order.status
OrderModel.change_order_status_by_main_order_id(self.db, order_id, status)
OrderHistoryModel.set_order_status_by_server(self.db, order, pre_status, status)
self.finish_json()
def get(self):
merchant_id = self.current_user.merchant_id
order_id = self.get_query_argument('order_id', None)
hotel_name = self.get_query_argument('hotel_name', None)
checkin_date_start = self.get_query_argument(
'checkin_date_start', None)
checkin_date_end = self.get_query_argument('checkin_date_end', None)
customer = self.get_query_argument('customer', None)
order_status = self.get_query_argument('order_status', None)
create_time_start = self.get_query_argument('create_time_start', None)
create_time_end = self.get_query_argument('create_time_end', None)
start = self.get_query_argument('start', 0)
limit = self.get_query_argument('limit', 20)
if order_status:
order_status = order_status.split(',')
orders, total = OrderModel.search(self.db,
merchant_id, self.current_user.hotel_id, order_id, hotel_name,
checkin_date_start, checkin_date_end, customer, order_status,
create_time_start, create_time_end, start, limit)
self.finish_json(result={
'orders': [order.todict() for order in orders],
'total': total,
'start': start,
'limit': limit,
})
def cancel_order_by_user(self, user, order_id, reason):
session = self.session
order = OrderModel.get_by_id(session, order_id)
pre_status = order.status
if order.merchant_id != user.merchant_id:
raise CeleryException(100, 'merchant invalid')
if order.status not in [0, 100]:
raise CeleryException(1000, 'illegal status')
if not callback_order_server(order_id):
raise CeleryException(1000, 'callback order server error')
task = Cancel.cancel_order_by_user.delay(order_id, reason)
result = task.get()
if task.status == 'SUCCESS':
if result.status != pre_status:
OrderHistoryModel.set_order_status_by_user(session, user, result, pre_status, result.status)
PushInventoryTask().push_inventory.delay(order.roomtype_id)
return result
else:
if isinstance(result, Exception):
raise result
def get(self):
claims = get_jwt_claims()
if not claims['is_admin']:
return {'message': 'admin privilege required.'}, 401
orders = [order.json() for order in OrderModel.find_all()]
return {'orders': orders}, 200
def get(self):
merchant_id = self.current_user.merchant_id
start = self.get_query_argument('start', 0)
limit = self.get_query_argument('limit', 20)
orders, total = OrderModel.get_today_book_orders(self.db, merchant_id, start, limit, self.current_user.hotel_id)
self.finish_json(result={
'total': total,
'start': start,
'limit': limit,
'orders': [order.todict() for order in orders],
})
def get(self):
merchant_id = self.current_user.merchant_id
order_id = self.get_query_argument('order_id', None)
hotel_name = self.get_query_argument('hotel_name', None)
checkin_date_start = self.get_query_argument(
'checkin_date_start', None)
checkin_date_end = self.get_query_argument('checkin_date_end', None)
customer = self.get_query_argument('customer', None)
order_status = self.get_query_argument('order_status', None)
create_time_start = self.get_query_argument('create_time_start', None)
create_time_end = self.get_query_argument('create_time_end', None)
order_ids = self.get_query_argument('order_ids', None)
if order_ids:
order_ids = [int(order_id_) for order_id_ in order_ids.split(',')]
if order_status:
order_status = order_status.split(',')
orders, total = OrderModel.search_export_orders(self.db,
merchant_id, self.current_user.hotel_id, order_id, hotel_name,
checkin_date_start, checkin_date_end, customer, order_status,
create_time_start, create_time_end, order_ids)
wbk = xlwt.Workbook(encoding='utf-8', style_compression=0)
sheet = wbk.add_sheet('EBooking订单列表')
row = 0
sheet.write(row, 0, '订单确认号')
sheet.write(row, 1, '酒店名称')
sheet.write(row, 2, '房型')
sheet.write(row, 3, '床型')
sheet.write(row, 4, '房间数')
sheet.write(row, 5, '入店日期')
sheet.write(row, 6, '离店日期')
sheet.write(row, 7, '预约时间')
sheet.write(row, 8, '入住人')
sheet.write(row, 9, '确认类型')
sheet.write(row, 10, '每日价格')
sheet.write(row, 11, '总价')
sheet.write(row, 12, '订单状态')
for order in orders:
row += 1
self.write_one_row(sheet, row, order)
export_time = datetime.datetime.now()
file_name = 'orders_{}.xls'.format(export_time.strftime('%Y-%m-%d %H:%M:%S'))
self.set_header('Content-type', 'application/vnd.ms-excel')
self.set_header('Content-Disposition', 'attachment; filename="' + file_name + '"')
sio = StringIO.StringIO()
wbk.save(sio)
self.write(sio.getvalue())
def post(self):
merchant_id = self.get_argument('merchant_id', None)
if not merchant_id:
raise JsonException(-1, "缺少merchant_id")
update_time = self.get_argument('update_time', None)
start = int(self.get_argument('start', 0))
limit = int(self.get_argument('limit', 20))
order_id = self.get_argument('order_id', None)
status = self.get_argument('status', None)
try:
limit = 100 if limit > 100 else limit
orders, total = OrderModel.search_switch(self.db, merchant_id, update_time, start, limit, order_id, status)
except Exception, e:
raise JsonException(-1, e.message)
def confirm_order_by_user(self, user, order_id):
session = self.session
order = OrderModel.get_by_id(session, order_id)
pre_status = order.status
if order.merchant_id != user.merchant_id:
raise CeleryException(100, 'merchant not valid')
if order.status != 100:
raise CeleryException(200, 'illegal status')
if callback_order_server(order_id):
order.confirm_by_user(session)
if order.status != pre_status:
OrderHistoryModel.set_order_status_by_user(session, user, order, pre_status, order.status)
return order
else:
raise CeleryException(1000, 'callback order server fail')
def cancel_order_by_server(self, order_id):
session = self.session
order = OrderModel.get_by_id(session, order_id)
pre_status = order.status
if order.status == 0 or order.status == 100:
_order = cancel_before_user_confirm(session, order.id)
elif order.status == 200:
raise CeleryException(1000, 'illegal status')
elif order.status == 300:
_order = cancel_after_user_confirm(session, order.id)
elif order.status in [400, 500, 600]:
return order
else:
raise CeleryException(1000, 'illegal status')
if _order.status != pre_status:
OrderHistoryModel.set_order_status_by_server(session, _order, pre_status, _order.status)
return _order
def post(self, order_id):
order = OrderModel.get_by_id(self.db, order_id)
pre_status = order.status
if order.merchant_id != self.merchant.id:
raise JsonException(100, 'merchant not valid')
if order.status != 100:
raise JsonException(200, 'illegal status')
if self.current_user.type == UserModel.TYPE_SUB and order.hotel_id != self.current_user.hotel_id:
raise JsonException(500, 'illegal hotel')
if (yield self.callback_order_server(order)):
order.confirm_by_user(self.db)
if order.status != pre_status:
OrderHistoryModel.set_order_status_by_user(
self.db, self.current_user, order, pre_status, order.status)
else:
raise JsonException(1000, 'callback order server fail')
self.finish_json(result=dict(
order=order.todict(),
))
def cancel_order_by_server(self, order_id):
order = OrderModel.get_by_id(self.db, order_id)
if not order:
raise JsonException(2000, 'no order')
pre_status = order.status
if order.status == 0 or order.status == 100:
_order = yield self.cancel_before_user_confirm(order.id)
elif order.status == 300:
_order = yield self.cancel_after_user_confirm(order.id)
elif order.status in [400, 500, 600]:
raise gen.Return(order)
elif self.current_user.type == UserModel.TYPE_SUB and order.hotel_id != self.current_user.hotel_id:
raise JsonException(500, 'illegal hotel')
else:
raise JsonException(1000, 'illegal status')
if _order.status != pre_status:
OrderHistoryModel.set_order_status_by_server(self.db, _order, pre_status, _order.status)
raise gen.Return(_order)
def post(self, order_id):
merchant_id = self.current_user.merchant_id
args = self.get_json_arguments()
reason, = get_and_valid_arguments(args, 'reason')
if not reason:
raise JsonException(200, 'invalid reason')
order = OrderModel.get_by_id(self.db, order_id)
pre_status = order.status
if order.merchant_id != merchant_id:
raise JsonException(300, 'merchant invalid')
if order.status not in [0, 100]:
raise JsonException(400, 'illegal status')
if self.current_user.type == UserModel.TYPE_SUB and order.hotel_id != self.current_user.hotel_id:
raise JsonException(500, 'illegal hotel')
if not (yield self.callback_order_server(order)):
raise JsonException(1000, 'callback order server error')
task = yield gen.Task(Cancel.cancel_order_by_user.apply_async,
args=[order_id, reason])
if task.status == 'SUCCESS':
order = task.result
if order.status != pre_status:
OrderHistoryModel.set_order_status_by_user(
self.db, self.current_user, order, pre_status, order.status)
self.finish_json(result=dict(
order=order.todict(),
))
else:
if isinstance(task.result, CeleryException):
raise JsonException(1000, task.result.errmsg)
else:
raise JsonException(1000, 'network error')
def get_order(session, order_id):
return OrderModel.get_by_id(session, order_id)
def get(self, merchant_id):
orders, total = OrderModel.get_waiting_orders(self.db, merchant_id)
self.finish_json(result=dict(
has_new_order=True if orders else False,
))
def get_order_in_date(self, merchant_id, year, month, pay_type, ota_ids=None):
orders = OrderModel.get_success_order_by_checkout_date_in_month(self.db,
merchant_id, year, month, pay_type, ota_ids)
return orders
