def get(self):
form = OrderListForm()
products = Product.objects(seller_id=current_user.id)
status = request.args.get('status')
if status == ORDER_STATUS['TRANSFERING']:
orders = Order.objects(product_id__in=products,
status=ORDER_STATUS["TRANSFERING"])
elif status == ORDER_STATUS['RECEIPTING']:
orders = Order.objects(product_id__in=products,
status=ORDER_STATUS["RECEIPTING"])
elif status == ORDER_STATUS['COMPLETE']:
orders = Order.objects(product_id__in=products,
status=ORDER_STATUS["COMPLETE"])
elif status == ORDER_STATUS['CANCEL']:
orders = Order.objects(product_id__in=products,
status=ORDER_STATUS["CANCEL"])
else:
status = ORDER_STATUS["ALL"]
orders = Order.objects(product_id__in=products)
orders = sorted(orders, key=lambda k: k.create_time, reverse=False)
return render_template('user/selling/order.html',
orders=orders,
ORDER_STATUS=ORDER_STATUS,
status=status,
form=form)
def post(self, user_id):
# Get arguments
args = self.parser.parse_args()
# Validate user, address and cleaner ids
if User.get_by_id(user_id) is None:
abort(404, 'User not found')
if Address.get_by_id(args['address_id']) is None:
abort(404, 'Address not found')
if Cleaner.get_by_id(args['cleaner_id']) is None:
abort(404, 'Cleaner not found')
# Create new order
order = Order(user_id=user_id,
address_id=args['address_id'],
cleaner_id=args['cleaner_id'],
date=args['date'],
start_time=args['start_time'],
end_time=args['end_time'],
rooms=args['rooms'],
special_rooms=args['special_rooms'],
extra_services=args['extra_services'],
reference=args['reference'],
transaction=args['transaction'],
price=args['price'])
# Persist and return order
success = order.persist()
if not success:
abort(400, 'Parameters incorrect')
return order, 201
def get(self):
payments = Payment.objects(payer_id=current_user.id, confirm=True)
buy_orders = Order.objects(buyer_id=current_user.id, status__ne=ORDER_STATUS["CANCEL"])
sell_orders = Order.objects(product_id__in=Product.objects(seller_id=current_user.id), status=ORDER_STATUS["COMPLETE"])
records = list()
for payment in payments:
record = Record("儲值", payment.amount, payment.create_time)
records.append(record)
for order in buy_orders:
if order.product_id.bidding == False:
if order.coupon_id == None:
record = Record("購買" + order.product_id.name, -1 * int(order.product_id.price * order.product_id.discount), order.create_time)
else:
record = Record("購買" + order.product_id.name, -1 * max(0, int(order.product_id.price * order.product_id.discount - order.coupon_id.discount)), order.create_time)
else:
record = Record("購買" + order.product_id.name, -1 * order.product_id.bid.now_price, order.create_time)
records.append(record)
for order in sell_orders:
if order.product_id.bidding == False:
record = Record("販賣" + order.product_id.name, int(order.product_id.price * RATE), order.finish_time)
else:
record = Record("販賣" + order.product_id.name, int(order.product_id.bid.now_price * RATE), order.finish_time)
records.append(record)
records = sorted(records, key=lambda k: k.time, reverse=True)
return render_template('user/hicoin/record.html', records=records)
def __create_order(self, snap):
'''将订单写入到数据库'''
order_no = OrderService.make_order_no()
with db.auto_commit():
order = Order()
order.user_id = self.uid
order.order_no = order_no
order.total_price = snap['order_price']
order.total_count = snap['total_count']
order.snap_img = snap['snap_img']
order.snap_name = snap['snap_name']
order.snap_address = snap['snap_address']
order.snap_items = json.dumps(snap['p_status'], ensure_ascii=False)
db.session.add(order)
db.session.flush() # 刷新数据库缓存，不操作事务
order_id = order.id # 获取更新后的order信息
for p in self.o_products:
# 起初每个p的格式 {'product_id': x, 'count': y}
p['order_id'] = order_id
db.session.add_all([
Order2Product(p['order_id'], p['product_id'], p['count'])
for p in self.o_products
])
return {
'order_no': order_no,
'order_id': order_id,
'create_time': order.create_time
}
def create_order():
data, errors = OrderAmountInputSchema().load(request.get_json())
if errors:
return make_response(jsonify(errors), 422)
tickets_dict = data['tickets']
order_amount = calculate_order_amount(tickets_dict, data.get('discount_code'))
ticket_ids = {ticket['id'] for ticket in tickets_dict}
ticket_map = {int(ticket['id']): ticket for ticket in tickets_dict}
tickets = (
Ticket.query.filter_by(deleted_at=None).filter(Ticket.id.in_(ticket_ids)).all()
)
if not tickets:
raise UnprocessableEntityError(
{'source': 'tickets'},
"Tickets missing in Order request",
)
event = tickets[0].event
try:
attendees = []
for ticket in tickets:
for _ in range(ticket_map[ticket.id]['quantity']):
ticket.raise_if_unavailable()
attendees.append(
TicketHolder(firstname='', lastname='', ticket=ticket, event=event)
)
db.session.commit()
except Exception as e:
db.session.rollback()
raise e
validate_attendees({attendee.id for attendee in attendees})
if data.get('amount') is not None and (
current_user.is_staff or has_access('is_coorganizer', event_id=event.id)
):
# If organizer or admin has overrided the amount of order
order_amount['total'] = data['amount']
order = Order(
amount=order_amount['total'],
event=event,
discount_code_id=data.get('discount_code'),
ticket_holders=attendees,
)
db.session.commit()
order.populate_and_save()
order_tickets = OrderTicket.query.filter_by(order_id=order.id).all()
for order_ticket in order_tickets:
ticket_info = ticket_map[order_ticket.ticket.id]
order_ticket.price = ticket_info.get('price')
save_to_db(order_ticket)
return OrderSchema().dump(order)
def expense(self):
params = request.args.get("type", None)
if params == "ship":
orders = Order.group_service_orders(kind="ship")
elif params == "deduct":
orders = Order.group_service_orders(kind="intro")
else:
orders = Order.group_service_orders()
return dict(msg="ok", code=200, orders=orders)
def create_order():
if not request.json:
abort(400)
order = Order()
order.user_id = request.json.get('user_id', "")
order.service_name = request.json.get('service_name', "")
order.service_type = request.json.get('service_type', "")
db.session.add(order)
db.session.commit()
return jsonify({'order': order.to_json()}), 201
def setUp(self):
self.BaseSetUp()
self.mock_order = Order(is_deleted=False,
created_at=datetime.now(),
id=1,
user_id=1,
date_booked_for=date.today(),
date_booked=date.today(),
channel='web',
meal_period='lunch',
order_status='booked',
has_rated=True,
menu_id=1,
location_id=1)
self.mock_deleted_order = Order(is_deleted=True,
created_at=datetime.now(),
id=1,
user_id='mock',
date_booked_for=date.today(),
date_booked=date.today(),
channel='web',
meal_period='lunch',
order_status='booked',
has_rated=True,
menu_id=1,
location_id=1)
self.mock_collected_order = Order(is_deleted=False,
created_at=datetime.now(),
id=1,
user_id='mock',
date_booked_for=date.today(),
date_booked=date.today(),
channel='web',
meal_period='lunch',
order_status='collected',
has_rated=True,
menu_id=1,
location_id=1)
self.mock_meal_item = MealItem(is_deleted=False,
created_at=datetime.now(),
updated_at=datetime.now(),
id=1,
meal_type='main',
name='mock',
image='mock',
location_id=1)
self.pagination_meta = {
'total_rows': 1,
'total_pages': 1,
'current_page': 1,
'next_page': False,
'prev_page': False
}
self.faker = Faker()
self.faker.add_provider(date_time)
def add_order_service(data):
"""
生成订单
:param data:[
{
"product_id": 78, # 产品id
"product_num": 2, # 产品数量
}
]
:return:
"""
session = g.session
user_id = get_user_info()["user_id"]
for item in to_list(data):
result = session.query(Product).filter(
Product.id == item["product_id"]).one()
order = Order()
order.order_num = date_time(fmt="%Y%m%d%H%M%S") + str(user_id) + str(
item["product_id"])
order.product_id = item["product_id"]
order.buyer_id = user_id
order.seller_id = result.publisher_id
order.product_num = item["product_num"]
order.product_amount = item["product_num"] * result.price
order.logistics_amount = result.logistics_price
session.add(order)
session.commit()
return True
def report_orders(self):
return dict(msg="ok",
code=200,
total_amount=Order.total_income_amount(),
total_count=Order.total_orders_count(),
total_amount_month=Order.total_income_amount(current=True),
total_count_month=Order.total_orders_count(current=True),
expense=Order.expense_total_amount(),
profit=Order.expense_total_amount(profit=True),
sale=Order.total_income_amount(kind="intro"),
install=Order.total_income_amount(kind="install"),
ship=Order.total_income_amount(kind="ship"),
measure=Order.total_income_amount(kind="measure"))
def get_pay_close(oid):
uid = g.user.uid
order = Order.query.filter(
and_(Order.user_id == uid, Order.order_no == oid,
Order.status == 1)).first_or_404()
pay_info = CloseOrder(oid).get_close_info()
if pay_info['result_code'] == 'FAIL':
return UserException(msg=pay_info['err_code'])
Order.restore_product_stock(dict(order)['snap_product'])
with db.auto_commit():
order.status = 0
order.update()
return Success(msg='订单已关闭')
def delete_order(oid):
resp_data = {'code': 200, 'msg': '查询成功~~', 'data': {}}
addNav(resp_data)
uid = current_user.id
order = Order()
with db.auto_commit():
order.deleteOrderById(oid)
userAllOrderList = order.getUserAllOrderList(uid)
orderCollection = OrderCollection(userAllOrderList)
resp_data['data'] = orderCollection.data
return render_template('order.html', data=resp_data)
def run():
"""
Create 4 orders seeds
"""
userid = [1, 2, 2, 3]
status = ['reserved', 'confirmed', 'reserved', 'confirmed']
for i in range(0, 4):
orderrow = Order()
orderrow.user_id = userid[i]
orderrow.status = status[i]
db.session.add(orderrow)
db.session.commit()
def post(self):
data = request.get_json()
orderDict = orderSchema.load(data)
product = Product.get_by_id((orderDict['product']['id']))
order = Order(orderDict['productName'], orderDict['totalProduct'],
orderDict['totalCompra'], product)
totalCalculado = calculateTotalCompra(product)
if (totalCalculado != order.totalCompra):
print(totalCalculado)
print('error son diferentes')
else:
order.save()
resp = orderSchema.dump(order)
return resp, 201
def create(self, payloads):
self.model_order = Order()
order_details = payloads['order_details']
self.model_order.user_id = payloads['user_id']
self.model_order.status = 'pending'
referal = db.session.query(Referal).filter_by(
referal_code=payloads['referal_code'])
if (referal.first() is not None):
self.model_order.referal_id = referal.first().as_dict()['id']
db.session.add(self.model_order)
try:
db.session.commit()
data = self.model_order.as_dict()
# insert the order details
order_id = data['id']
order_items = []
for item in order_details:
order_item = OrderDetails()
order_item.ticket_id = item['ticket_id']
order_item.count = item['count']
order_item.order_id = order_id
# get ticket data
ticket = self.get_ticket(item['ticket_id'])
if payloads['payment_type'] == 'paypal':
order_item.price = ticket.usd_price
else:
order_item.price = ticket.price
db.session.add(order_item)
db.session.commit()
order_items.append(order_item.as_dict())
if payloads['payment_type'] == 'offline':
gross_amount = (item['count'] * ticket.price)
payment = Payment()
payment.order_id = order_id
payment.payment_type = 'offline'
payment.gross_amount = gross_amount
payment.transaction_time = datetime.datetime.now()
payment.transaction_status = 'pending'
db.session.add(payment)
db.session.commit()
# if payloads['payment_type'] == 'paypal':
# self.paypalorder(payloads)
# save all items
return {'error': False, 'data': data, 'included': order_items}
except SQLAlchemyError as e:
data = e.orig.args
return {'error': True, 'data': data}
def create_order(form, from_organizer=False):
order = Order()
order.status = 'pending'
order.identifier = TicketingManager.get_new_order_identifier()
order.event_id = form.get('event_id')
if from_organizer:
order.paid_via = form.get('payment_via')
ticket_ids = form.getlist('ticket_ids[]')
ticket_quantity = form.getlist('ticket_quantities[]')
ticket_discount=form.get('promo_code','')
discount=None
if ticket_discount:
discount=TicketingManager.get_discount_code(form.get('event_id'), form.get('promo_code',''))
if not discount:
flash('The promotional code entered is not valid. No offer has been applied to this order.', 'danger')
else:
flash('The promotional code entered is valid.offer has been applied to this order.', 'success')
ticket_subtotals = []
if from_organizer:
ticket_subtotals = form.getlist('ticket_subtotals[]')
amount = 0
for index, id in enumerate(ticket_ids):
if not string_empty(id) and int(ticket_quantity[index]) > 0:
with db.session.no_autoflush:
order_ticket = OrderTicket()
order_ticket.ticket = TicketingManager.get_ticket(id)
order_ticket.quantity = int(ticket_quantity[index])
order.tickets.append(order_ticket)
if from_organizer:
amount += int(ticket_subtotals[index])
else:
amount += (order_ticket.ticket.price * order_ticket.quantity)
if discount and discount.type=="amount":
order.amount = max(amount-discount.value,0)
elif discount:
order.amount=amount-(discount.value*amount/100)
else:
order.amount=amount
if login.current_user.is_authenticated:
order.user_id = login.current_user.id
save_to_db(order)
return order
def get_paginate_by_status(status):
member = get_current_member()
start, count = paginate()
res = Order.get_paginate(member.id, start, count, status, throw=True)
for order in res['models']:
order.hide('snap_address', 'snap_products')
return jsonify(res)
def orders(self):
page = request.args.get("page", 1)
orders, page = Order.complete_orders(page)
return dict(msg="ok",
code=200,
orders=[o.to_json() for o in orders],
page=page)
def get_summary():
'''获取全部订单简要信息(分页)'''
validator = PaginateValidator().validate_for_api()
paged_orders = OrderModel.get_summary_by_user(uid=g.user.uid,
page=validator.page.data,
size=validator.size.data)
return Success(paged_orders)
async def update_item_list(self, db: Session, *, order_db: Order,
order_update: OrderUpdate) -> Order:
db.query(ItemOrder).filter(ItemOrder.order_id == order_db.id).delete()
item_orders: List[ItemOrder] = []
for item in order_update.items_in_order:
item_order = ItemOrder(
tot_price=item.tot_price,
quantity=item.quantity,
order_id=order_db.id,
item_id=item.item_id,
)
item_orders.append(item_order)
order_db.items = item_orders
db.add(order_db)
db.commit()
db.flush(order_db)
return order_db
def get(self):
form = CouponForm()
if request.args.get('status') == str(COUPON_STATUS["ALL"]):
coupons = list(
Information.objects(user_id=current_user.id).first().coupon)
for i in range(len(coupons) - 1, -1, -1):
if coupons[i].status == COUPON_STATUS[
"EXPIRED"] or Order.objects(
buyer_id=current_user.id,
coupon_id=coupons[i].id,
status__ne=ORDER_STATUS["CANCEL"]).first() != None:
del coupons[i]
status = COUPON_STATUS["ALL"]
else:
coupons = Coupon.objects(
id__nin=[
coupon.id for coupon in Information.objects(
user_id=current_user.id).first().coupon
],
begin_time__lte=datetime.datetime.utcnow() +
datetime.timedelta(hours=8),
status=COUPON_STATUS["ACTIVE"])
status = None
return render_template('user/coupon/list.html',
status=status,
coupons=coupons,
form=form,
COUPON_STATUS=COUPON_STATUS)
def get_pay_order(oid):
uid = g.user.uid
user = User.query.filter_by(id=uid).first().append('openid')
order = Order.get_one_order(oid)
wx_pay = UnifiedOrder(oid, user.openid, order.pay_price)
pay_info = wx_pay.get_pay_info()
return jsonify(pay_info)
def create_order():
uid = g.user.uid
form = CreateOrderValidator().validate_for_api()
order_no = Order.create_order(form.product_ids.data, form.address_id.data,
form.user_coupon_id.data, form.remark.data,
uid)
return jsonify(order_no)
def create_order(self, db: Session, invoice_id, order, total):
db_order = Order(
product_image=order.image,
product_name=order.product_name,
name=order.name,
street=order.street,
number=order.number,
neighborhood=order.neighborhood,
complement=order.complement,
zip=order.zip,
city=order.city,
uf=order.uf,
cellphone=order.cellphone,
note=order.note,
total=total,
status="created",
invoice_id=invoice_id,
created_at=datetime.now(),
merchant_id=order.merchant_id,
type_id=order.type_id,
)
db.add(db_order)
db.commit()
db.refresh(db_order)
return db_order
def put(self, order_id):
# Get order by id
order = Order.get_by_id(order_id)
if order is None:
abort(404)
# Update order fields
args = self.parser.parse_args()
order.cleaner_id = assign(args['cleaner_id'], order.cleaner_id)
order.address_id = assign(args['address_id'], order.address_id)
order.date = assign(args['date'], order.date)
order.start_time = assign(args['start_time'], order.start_time)
order.end_time = assign(args['end_time'], order.end_time)
order.rooms = assign(args['rooms'], order.rooms)
order.special_rooms = assign(args['special_rooms'],
order.special_rooms)
order.extra_services = assign(args['extra_services'],
order.extra_services)
order.reference = assign(args['reference'], order.reference)
order.transaction = assign(args['transaction'], order.transaction)
order.price = assign(args['price'], order.price)
# Persist changes and return order
order.persist()
return order
def get_summary_by_user():
'''订单摘要: 按用户查询&分页'''
validator = PaginateValidator().validate_for_api()
page = validator.page.data
size = validator.size.data
paging_orders = OrderModel.get_summary_by_user(g.user.uid, page, size)
return Success(paging_orders)
def order_delete():
meta = {
'title': '订单管理',
'css_nav_sub_order': 'active',
'css_nav_reptile': 'active'
}
ids = request.values.get('ids', '')
type = request.values.get('type', 1)
if not ids:
return jsonify(success=False, message='缺少请求参数!')
try:
arr = ids.split(',')
for d in arr:
order = Order.objects(_id=bson.objectid.ObjectId(d)).first()
order.mark_delete() if order else None
except (Exception) as e:
return jsonify(success=False, message=str(e))
return jsonify(success=True,
message='操作成功!',
data={
'ids': ids,
'type': type
},
redirect_to=url_for('admin.order_list'))
def delete(self, order_id):
# Delete order
success = Order.delete_by_id(order_id)
if not success:
abort(404)
return {'result': True}
def check_login():
"""
获取用户请求头中的 Headers 中的 Authorization的值
根据这个的值找出数据库中的用户的解析, 并且返回用户
如果没有找到就返回错误
"""
token = request.headers.get("Authorization", None)
if not token:
return dict(msg="需要授权登录才能访问", code=419)
user = User.conver_token(token)
if not user:
return dict(msg="登录验证失效", code=419)
User.set_account(user.account_id)
Order.set_account(user.account_id)
Order.set_current_user(user)
g.current_user = user
g.current_account = user.current_account
def get(self, order_id):
# Get order by id
order = Order.get_by_id(order_id)
if order is None:
abort(404)
# Return order
return order
def test_create_order_rating_when_order_already_rated(
self, mock_vendor_engagement_repo_get, mock_meal_item_repo_get,
mock_auth_user, mock_vendor_rating_controller_request_params,
mock_order_repo_get):
'''Test create_order_rating when order has already been rated.
'''
# Arrange
with self.app.app_context():
mock_meal_item = MealItem(id=1,
created_at=datetime.now(),
updated_at=datetime.now(),
meal_type='main',
name='Mock meal',
image='',
location_id=1)
mock_vendor_engagement = VendorEngagement(
id=1,
created_at=datetime.now(),
updated_at=datetime.now(),
vendor_id=1,
location_id=1,
start_date=datetime.now(),
end_date=(datetime.now() + timedelta(days=5)),
status=1,
termination_reason='Mock reason')
mock_order = Order(id=1,
created_at=datetime.now(),
updated_at=datetime.now(),
user_id='user_id',
date_booked_for=datetime.now(),
date_booked=datetime.now(),
channel='web',
meal_period='lunch',
order_status='booked',
has_rated=True,
menu_id=1,
location_id=1)
mock_vendor_rating_controller_request_params.return_value = (1,
None,
None,
None,
3,
None,
None)
mock_auth_user.return_value = 1
mock_meal_item_repo_get.return_value = mock_meal_item
mock_vendor_engagement_repo_get.return_value = \
mock_vendor_engagement
mock_order_repo_get.return_value = mock_order
vendor_rating_controller = VendorRatingController(
self.request_context)
# Act
result = vendor_rating_controller.create_order_rating()
# Assert
assert result.status_code == 400
assert result.get_json()['msg'] == 'This order has been rated'
def create_order(form, from_organizer=False):
order = Order()
order.status = 'pending'
order.identifier = TicketingManager.get_new_order_identifier()
order.event_id = form.get('event_id')
if from_organizer:
order.paid_via = form.get('payment_via')
ticket_ids = form.getlist('ticket_ids[]')
ticket_quantity = form.getlist('ticket_quantities[]')
ticket_subtotals = []
if from_organizer:
ticket_subtotals = form.getlist('ticket_subtotals[]')
amount = 0
for index, id in enumerate(ticket_ids):
if not string_empty(id) and int(ticket_quantity[index]) > 0:
with db.session.no_autoflush:
order_ticket = OrderTicket()
order_ticket.ticket = TicketingManager.get_ticket(id)
order_ticket.quantity = int(ticket_quantity[index])
order.tickets.append(order_ticket)
if from_organizer:
amount += int(ticket_subtotals[index])
else:
amount += (order_ticket.ticket.price * order_ticket.quantity)
order.amount = amount
if login.current_user.is_authenticated:
order.user_id = login.current_user.id
save_to_db(order)
return order
def create_order(form, from_organizer=False):
order = Order()
order.status = 'pending'
order.identifier = TicketingManager.get_new_order_identifier()
order.event_id = form.get('event_id')
if from_organizer:
order.paid_via = form.get('payment_via')
ticket_ids = form.getlist('ticket_ids[]')
ticket_quantity = form.getlist('ticket_quantities[]')
ticket_discount = form.get('promo_code', '')
discount = None
if ticket_discount:
discount = TicketingManager.get_discount_code(form.get('event_id'), form.get('promo_code', ''))
access_code = TicketingManager.get_access_code(form.get('event_id'), form.get('promo_code', ''))
if access_code and discount:
order.discount_code = discount
flash('Both access code and discount code have been applied. You can make this order now.', 'success')
elif discount:
order.discount_code = discount
flash('The promotional code entered is valid. Offer has been applied to this order.', 'success')
elif access_code:
flash('Your access code is applied and you can make this order now.', 'success')
else:
flash('The promotional code entered is not valid. No offer has been applied to this order.', 'danger')
ticket_subtotals = []
if from_organizer:
ticket_subtotals = form.getlist('ticket_subtotals[]')
amount = 0
total_discount = 0
fees = DataGetter.get_fee_settings_by_currency(DataGetter.get_event(order.event_id).payment_currency)
for index, id in enumerate(ticket_ids):
if not string_empty(id) and int(ticket_quantity[index]) > 0:
with db.session.no_autoflush:
order_ticket = OrderTicket()
order_ticket.ticket = TicketingManager.get_ticket(id)
order_ticket.quantity = int(ticket_quantity[index])
order.tickets.append(order_ticket)
if order_ticket.ticket.absorb_fees or not fees:
ticket_amount = (order_ticket.ticket.price * order_ticket.quantity)
amount += (order_ticket.ticket.price * order_ticket.quantity)
else:
order_fee = fees.service_fee * (order_ticket.ticket.price * order_ticket.quantity) / 100
if order_fee > fees.maximum_fee:
ticket_amount = (order_ticket.ticket.price * order_ticket.quantity) + fees.maximum_fee
amount += (order_ticket.ticket.price * order_ticket.quantity) + fees.maximum_fee
else:
ticket_amount = (order_ticket.ticket.price * order_ticket.quantity) + order_fee
amount += (order_ticket.ticket.price * order_ticket.quantity) + order_fee
if from_organizer:
amount += float(ticket_subtotals[index])
else:
if discount and str(order_ticket.ticket.id) in discount.tickets.split(","):
if discount.type == "amount":
total_discount += discount.value * order_ticket.quantity
else:
total_discount += discount.value * ticket_amount / 100
if discount:
order.amount = max(amount - total_discount, 0)
elif discount:
order.amount = amount - (discount.value * amount / 100.0)
else:
order.amount = amount
if login.current_user.is_authenticated:
order.user_id = login.current_user.id
save_to_db(order)
return order
