def test_language_info(self):
language_info = header_parser.parse_language(self.dummy_meta)
self.assertEqual(language_info[0], False)
self.assertEqual(language_info[1], 'default')
self.dummy_meta = {'HTTP_ACCEPT_LANGUAGE': 'zh'}
language_info = header_parser.parse_language(self.dummy_meta)
self.assertEqual(language_info[0], True)
self.assertEqual(language_info[1], 'aries_cn')
def post(self, request):
language_info = header_parser.parse_language(request.META)
try:
coupon_data = coupon_util.event_coupon_validator(
request, language_info[0])
open_id = coupon_data['open_id']
coupon_id = coupon_data['coupon_id']
coupon_list = [(coupon_id, 0, self.r_code, 'ADMIN')]
coupon_manager = CouponManagerV3(logger_info, logger_error)
coupon_manager.create_coupon(open_id, coupon_list)
except BusinessLogicError as instance:
message = instance.args
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
message)
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
try:
open_id = request_data['open_id']
product_list = request_data['product_list']
order_id = request_data['order_id']
hub_id = request_data['hub_id']
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid(Token or Open id)')
return Response(result.get_response(), result.get_code())
language_info = header_parser.parse_language(request.META)
date_info = product_util.get_date_information(hub_id, product_util.get_sales_time_str())
product_manager = ProductManager(logger_info, logger_error, language_info, date_info)
review_manager = ReviewManager(logger_info, logger_error)
product_list = [product_manager.get_product(product['product_id']) for product in product_list]
response_list = [review_manager.get_personal_review(language_info[2], open_id, order_id, product)
for product in product_list]
result.set('reviews', response_list)
result.set('review_items', review_manager.review_items)
return Response(result.get_response(), result.get_code())
def get(self, request):
auth_info = header_parser.parse_authentication(request)
language_info = header_parser.parse_language(request.META)
event_manager = EventManager(self.logger_info, self.logger_error)
try:
# Get event manager
event_object = event_manager.get_event_status(
auth_info, None, language_info[0])
event = event_object['event']
if event['need_auth']:
user_util.check_auth_info(auth_info)
# Check game play condition
event_util.check_play_condition(event, language_info[0])
# Play the game
reward_result = event_manager.draw_event(event['id'],
language_info[0])
reward_id = reward_result[0]
random_number = reward_result[1]
# Make the history
create_result = event_manager.create_event_history(
event['id'], auth_info[0], reward_id, random_number,
language_info[0])
# Reward interface to purchase server
reward_tuple = create_result[2]
event_manager.create_coupon(auth_info[0], reward_tuple.target_id,
language_info[0])
# Coupon count increase
event_manager.increase_coupon_count(auth_info[0], auth_info[1])
except AuthInfoError as e:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED, str(e))
except BusinessLogicError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
message)
result.set_error(err_code)
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('event_reward', create_result[1])
return Response(result.get_response(), result.get_code())
def get(self, request):
auth_info = header_parser.parse_authentication(request)
language_info = header_parser.parse_language(request.META)
event_manager = EventManager(self.logger_info, self.logger_error)
try:
event = event_manager.get_event_status(auth_info, None,
language_info[0])
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('event', event['event'])
result.set('event_reward', event['event_reward'])
result.set('event_info', event['event_info'])
return Response(result.get_response(), result.get_code())
def get(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
# Get access token
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1]
language_info = header_parser.parse_language(request.META)
cn_header = language_info[0]
page = int(request.GET.get('page'))
limit = int(request.GET.get('limit'))
user = User.objects.get(access_token=access_token, open_id=open_id)
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Token or user not found')
return Response(result.get_response(), result.get_code())
# My News part
try:
user_news_list = UserNews.objects.filter(user=user)
user_news_count = user_news_list.count()
paginator = Paginator(user_news_list, limit)
user_news = paginator.page(page).object_list
serializer = UserNewsSerializer(user_news, many=True)
news_data = serializer.data
user_manager = UserManager()
news_list = [user_manager.parse_my_news(news, cn_header) for news in news_data]
result.set('total_count', user_news_count)
result.set('news', news_list)
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data error')
return Response(result.get_response(), result.get_code())
return Response(result.get_response(), result.get_code())
def get(self, request):
auth_info = header_parser.parse_authentication(request)
language_info = header_parser.parse_language(request.META)
try:
coupon_util.auth_info_validator(auth_info, language_info[0])
coupon_util.os_info_validator(request)
coupon_manager = CouponManagerV3(logger_info, logger_error)
coupon_manager.create_coupon_pack(auth_info, self.coupon_pack_info,
language_info[0])
except BusinessLogicError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
message)
result.set_error(err_code)
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS_MSG)
language_info = header_parser.parse_language(request.META)
cn_header = language_info[0]
target_db = language_info[1]
result_list = list()
result_product_list = list()
try:
request_data = request.data
os_type = request_data.get('os_type', 0)
hub_id = request_data.get('hub_id', 1)
product_list = request.data['product_list']
delivery_schedule = request.data['delivery_schedule']
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid')
return Response(result.get_response(), result.get_code())
first_product = True
product_order_name = ''
sales_time = 0
# Time bomb service
product_service = ProductService(logger_info, logger_error)
time_bomb_service = TimeBombService(logger_info, logger_error)
time_bomb_id = time_bomb_service.get_current_time_bomb_id(hub_id, os_type)
discount_info = {}
if time_bomb_id is not None:
discount_list = product_service.read_product_discount_info_with_id(time_bomb_id)
discount_info.update(get_discount_info_map(discount_list, cn_header))
for product in product_list:
try:
product_instance = Product.objects.get(id=product['product_id'])
menu_instance = Menu.objects.using(target_db).get(id=product_instance.menu.id)
hub_stock = HubStock.objects.get(hub=product_instance.hub, menu=menu_instance)
# Check sales_time
sales_time = product_instance.sales_time
# Check real stock unit
order_quantity = product['quantity']
stock = hub_stock.stock
if stock < order_quantity:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Product already sold')
error_code = code.ERROR_3001_PRODUCT_ALREADY_SOLD
result.set_error(error_code)
error_message = get_msg(error_code, cn_header)
error_message += ' [' + menu_instance.name + ']'
result.set_error_message(error_message)
return Response(result.get_response(), result.get_code())
# Check schedule time
if not check_delivery_schedule(delivery_schedule):
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Schedule invalid')
error_code = code.ERROR_3015_PRODUCT_DELIVERY_TIME_INVALID
error_message = get_msg(error_code, cn_header)
result.set_error(error_code)
result.set_error_message(error_message)
return Response(result.get_response(), result.get_code())
# Product information
product_serializer = ProductListInfoSerializer(product_instance)
product_data = product_serializer.data
menu_serializer = MenuValidationSerializer(menu_instance)
menu_data = menu_serializer.data
product_data['menu'] = menu_data
product_data['quantity'] = product['quantity']
# Add time bomb information
if product_data['id'] in discount_info:
add_discount_information(product_data, discount_info[product_data['id']])
result_product_list.append(product_data)
if first_product:
product_order_name = product_instance.menu.name
# product_order_name = menu_instance.name
first_product = False
logger_info.info(str(stock) + ' ' + str(product['quantity']))
if stock >= product['quantity']:
result_list.append(product['product_id'])
except Exception as e:
print(e)
result.set('product_title', product_order_name)
# Check if result list is zero, don't display more
if int(len(result_list)-1) != 0:
result.set('product_sub', '(and ' + str(len(result_list)-1) + ' more)')
else:
result.set('product_sub', '')
result.set('sales_time', sales_time)
result.set('product_count', len(result_list))
result.set('product_index_list', result_list)
result.set('product_list', result_product_list)
return Response(result.get_response(), result.get_code())
def get(self, request, hub_id):
# Query the DeliverySchedule DB

result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
language_info = header_parser.parse_language(request.META)
target_db = language_info[1]
sales_time = 'ALL_DAY'
if request.query_params.get('sales_time'):
sales_time = request.query_params.get('sales_time').upper()
today = datetime.datetime.today()
next_working_day = today + datetime.timedelta(days=30)
try:
dlv_schedules = DeliverySchedule.objects.filter(working_day__range=[today, next_working_day])
if dlv_schedules.count() <= 0:
result.set('timetable', json.loads('[]'))
else:
target_schedule = dlv_schedules[0]
delivery_day = today
if delivery_day.time() > dlv_schedules[0].delivery_end:
if dlv_schedules.count() > 1:
target_schedule = dlv_schedules[1]
next_day = target_schedule.working_day
else:
target_schedule = dlv_schedules[0]
next_day = today + datetime.timedelta(days=1)
else:
next_day = today
if sales_time == 'LUNCH':
time_table = target_schedule.delivery_time_table_lunch
elif sales_time == 'DINNER':
time_table = target_schedule.delivery_time_table_dinner
else:
time_table = target_schedule.delivery_time_table
time_slots = json.loads(time_table)
result.set('working_day', next_day.strftime('%Y.%m.%d'))
available_time = 0
matched_index = []
for target_slot in time_slots:
time = datetime.datetime.strptime(
next_day.strftime("%Y.%m.%d") + ' ' + target_slot["starttime"], "%Y.%m.%d %I:%M %p"
)
if today > time:
available_time += 1
else:
matched_index.append(target_slot['index'])
try:
shipping_avail = ShippingAvailability.objects.get(hub_id=hub_id, ds_id=target_schedule)
except ShippingAvailability.DoesNotExist:
shipping_avail = ShippingAvailability(hub_id=hub_id, ds_id=target_schedule)
shipping_avail.save()
time_slots_avail = json.loads(shipping_avail.shipping_availability_table)
result_list = [target_time for slot in matched_index for target_time in time_slots_avail
if slot == target_time['index']]
if sales_time == 'LUNCH':
result_table = result_list
elif sales_time == 'DINNER':
result_table = result_list
else:
result_table = time_slots_avail[available_time:]
result.set('timetable', result_table)
except DeliverySchedule.DoesNotExist:
today = datetime.datetime.today()
today = today + datetime.timedelta(1)
result.set('timetable', json.loads('[]'))
result.set('working_day', today.strftime("%Y.%m.%d"))
result.set('shipping_detail', json.loads('[]'))
return Response(result.get_response(), result.get_code())
try:
shipping_methods = ShippingMethod.objects.using(target_db).filter(hub_id=hub_id)
shipping_method_list = ShippingMethodListSerializer(shipping_methods, many=True).data
result.set('shipping_detail', shipping_method_list)
except ShippingMethod.DoesNotExist:
print("ShippingMethod is not defined for hub id: {0}".format(hub_id))
result.set('shipping_detail', json.loads('[]'))
except Exception as e:
print(e)
result.set('shipping_detail', json.loads('[]'))
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
logger_info.info(request_data)
language_info = header_parser.parse_language(request.META)
cn_header = language_info[0]
order_data = dict()
coupon_instance_list = list()
# for getting daily order index
order_manager_v2 = OrderManagerV2(logger_info, logger_error)
# Step 1. Request data parsing
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1]
order_id = request_data['order_id']
payment_data = request_data['payment_data']
notification_order = request_data.get('alipay_notification_order', False)
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid(Token or Open id)')
return Response(result.get_response(), result.get_code())
# Step 1.5
order_count = Order.objects.filter(order_id=order_id, open_id=open_id).count()
if order_count == 1:
order = Order.objects.get(order_id=order_id, open_id=open_id)
purchase_order = PurchaseOrder.objects.get(order_id=order_id, open_id=open_id)
purchase_order_serializer = UpcomingPurchaseOrderSerializer(purchase_order)
purchase_order_data = purchase_order_serializer.data
purchase_order_data['order_details'] = json.loads(purchase_order_data['order_details'])
purchase_order_data['shipping_detail'] = json.loads(purchase_order_data['shipping_detail'])
del purchase_order_data['product_list']
del purchase_order_data['coupon_list']
del purchase_order_data['order_hash']
order_data = UpcomingOrderSerializer(order).data
order_data['order_start_date'] = dateformatter.get_ordering_complete_date_fmt(order.order_start_date)
order_data['order_status_history'] = json.loads(order_data['order_status_history'])
order_data['purchase_order'] = purchase_order_data
order_data['order_cancel_date'] = ''
# Get Timetable
order_data['timetable'] = json.loads('[]')
result.set('upcoming_order', order_data)
return Response(result.get_response(), result.get_code())
# Step 2. Check payment data validation and coupon check
try:
purchase_order = PurchaseOrder.objects.get(order_id=order_id, open_id=open_id,
status=self.PURCHASE_ORDER_STATUS_CREATED)
order_data['purchase_order'] = purchase_order.id
payment_type = purchase_order.payment_type
# Check payment data validation
payload = {'open_id': open_id, 'order_id': order_id, 'payment_type': payment_type,
'payment_raw_data': payment_data, 'price_unit': purchase_order.price_unit,
'price_total': purchase_order.price_total}
if notification_order:
payload['notification_order'] = True
else:
payload['notification_order'] = False
payment_url = payment_util.get_payment_app_url(purchase_order.payment_type)
response = requests.post(payment_url, json=payload)
logger_info.info(response.text)
payment_result = response.json()
if response.status_code != code.ARIES_200_SUCCESS:
if response.status_code == code.ARIES_400_BAD_REQUEST:
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
get_msg(code.ERROR_9000_INTERNAL_API_CALL_FAILED, cn_header))
elif payment_result['error_code'] == code.ERROR_4001_PAYMENT_VALIDATION_FAILED:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4001_PAYMENT_VALIDATION_FAILED, cn_header))
result.set_error(code.ERROR_4001_PAYMENT_VALIDATION_FAILED)
elif payment_result['error_code'] == code.ERROR_4005_PAYMENT_SYNC_ERROR:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4005_PAYMENT_SYNC_ERROR, cn_header))
purchase_order.status = 3
purchase_order.save()
return Response(result.get_response(), result.get_code())
logger_info.info('Payment finished')
# Order saved and coupon using section
coupon_list = json.loads(purchase_order.coupon_list)
logger_info.info(coupon_list)
for coupon in coupon_list:
coupon_id = coupon['coupon_id']
coupon_count = CustomerCoupon.objects.filter(id=coupon_id).count()
if coupon_count == 1:
coupon_instance = CustomerCoupon.objects.get(id=coupon_id)
coupon_instance.status = 1
coupon_instance.used_date = datetime.now()
coupon_instance_list.append(coupon_instance)
else:
logger_error.error(get_msg(code.ERROR_4001_PAYMENT_VALIDATION_FAILED))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4001_PAYMENT_VALIDATION_FAILED))
result.set_error(code.ERROR_4001_PAYMENT_VALIDATION_FAILED)
purchase_order.status = 3
purchase_order.save()
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_error.error(str(e))
error_code = code.ERROR_3002_PURCHASE_ORDER_NOT_FOUND
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code), cn_header)
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
# Step 3 Order data section
logger_info.info('Order data section')
# Order data
order_data['open_id'] = open_id
order_data['hub_id'] = purchase_order.hub_id
order_data['order_id'] = order_id
order_data['order_status'] = self.ORDER_STATUS_CREATED
history_date = dateformatter.get_yyyymmdd_now()
history_payload = [{'status': 0, 'datetime': history_date}]
order_data['order_status_history'] = json.dumps(history_payload)
order_data['order_daily_index'] = order_manager_v2.get_daily_order_index()
# Delivery data
is_on_site_pickup = purchase_order.delivery_on_site
address_id = purchase_order.delivery_address_id
# Check if it was on-site pickup or not
if is_on_site_pickup:
logger_info.info('On site pickup')
hub_name = hub_data.get_hub_name(cn_header, purchase_order.hub_id)
complete_address = hub_name + '\n - ' + hub_data.get_hub_address(cn_header, purchase_order.hub_id)
order_data['delivery_on_site'] = purchase_order.delivery_on_site
order_data['delivery_address'] = complete_address
else:
logger_info.info('NOT on site pickup')
try:
headers = {'open-id': str(open_id), 'authorization': 'bearer ' + access_token,
'Content-Type': 'application/json'}
response = requests.get(urlmapper.get_url('PRODUCT_ADDRESS_DETAIL') + '/' + str(address_id),
headers=headers)
except Exception as e:
logger_info.info(str(e))
if response.status_code == code.ARIES_200_SUCCESS:
response_json = response.json()['user_address']
logger_info.info(response_json)
# Set delivery address
recipient_name = response_json['recipient_name']
recipient_mdn = response_json['recipient_mdn']
if len(recipient_mdn) <= 0 and len(recipient_name) <= 0:
delivery_address = response_json['name']
else:
delivery_address = response_json['name'] + ' - ' + response_json['detail']
if len(delivery_address) > 300:
delivery_address = delivery_address[:300]
order_data['delivery_address'] = delivery_address
order_data['delivery_address_lat'] = response_json['latitude']
order_data['delivery_address_lng'] = response_json['longitude']
order_data['delivery_recipient_name'] = recipient_name
order_data['delivery_recipient_mdn'] = recipient_mdn
else:
# New address check
logger_info.info('Address not found error')
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
'Address not found')
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
return Response(result.get_response(), result.get_code())
logger_info.info('After on site pickup')
order_data['user_name'] = purchase_order.user_name
order_data['user_telephone'] = purchase_order.user_telephone
order_data['user_receipt'] = purchase_order.user_receipt
order_data['delivery_date'] = purchase_order.delivery_date
order_data['delivery_schedule'] = purchase_order.delivery_schedule
order_data['delivery_as_fast'] = purchase_order.delivery_as_fast
order_data['delivery_customer_name'] = purchase_order.user_name
order_data['delivery_telephone_state'] = 0
order_data['delivery_telephone'] = 'Delivery telephone'
pre_time = purchase_order.delivery_start_time
post_time = purchase_order.delivery_end_time
delivery_date = str(purchase_order.delivery_date).replace('-', '.')
order_data['delivery_time'] = delivery_date + ', ' + pre_time + '~' + post_time
# Shipping data
order_data['shipping_method'] = purchase_order.shipping_method
order_data['shipping_status'] = 0
# Step 4
logger_info.info('STEP 4')
order_count = Order.objects.filter(order_id=order_id, open_id=open_id).count()
if order_count == 1:
logger_info.info('Order exists')
order = Order.objects.get(order_id=order_id, open_id=open_id)
purchase_order = PurchaseOrder.objects.get(order_id=order_id, open_id=open_id)
purchase_order_serializer = UpcomingPurchaseOrderSerializer(purchase_order)
purchase_order_data = purchase_order_serializer.data
purchase_order_data['order_details'] = json.loads(purchase_order_data['order_details'])
purchase_order_data['shipping_detail'] = json.loads(purchase_order_data['shipping_detail'])
del purchase_order_data['product_list']
del purchase_order_data['coupon_list']
del purchase_order_data['order_hash']
order_data = UpcomingOrderSerializer(order).data
order_data['order_start_date'] = dateformatter.get_ordering_complete_date_fmt(order.order_start_date)
order_data['order_status_history'] = json.loads(order_data['order_status_history'])
order_data['purchase_order'] = purchase_order_data
order_data['order_cancel_date'] = ''
# Get Timetable
order_data['timetable'] = json.loads('[]')
result.set('upcoming_order', order_data)
return Response(result.get_response(), result.get_code())
# Step 5
# Create order object and send order data to client
logger_info.info('Step 5')
try:
order_serializer = OrderSerializer(data=order_data)
if order_serializer.is_valid():
order_serializer.save()
logger_info.info('Order valid and save success')
# Order save success and coupon save
for coupon_ins in coupon_instance_list:
coupon_ins.save()
# User notification url call
url = urlmapper.get_url('USER_NOTIFICATION') + '/coupon/1/' + str(len(coupon_instance_list))
headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token}
requests.get(url, headers=headers)
# Get special instruction and include cutlery information
include_cutlery = purchase_order.include_cutlery
special_inst = purchase_order.special_instruction
# Special instruction and include cutlery save call
url = urlmapper.get_url('USER_CART_INFO_SAVE')
headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token}
json_data = {'include_cutlery': include_cutlery, 'special_instruction': special_inst}
requests.put(url, headers=headers, json=json_data)
# After user notification
logger_info.info('After user notification request')
purchase_order_serializer = UpcomingPurchaseOrderSerializer(purchase_order)
purchase_order_data = purchase_order_serializer.data
purchase_order_data['order_details'] = json.loads(purchase_order_data['order_details'])
purchase_order_data['shipping_detail'] = json.loads(purchase_order_data['shipping_detail'])
del purchase_order_data['product_list']
del purchase_order_data['coupon_list']
del purchase_order_data['order_hash']
order_data = order_serializer.data
order = Order.objects.get(id=order_data['id'])
order_data = UpcomingOrderSerializer(order).data
order_data['order_start_date'] = dateformatter.get_ordering_complete_date_fmt(order.order_start_date)
order_data['order_status_history'] = json.loads(order_data['order_status_history'])
order_data['purchase_order'] = purchase_order_data
order_data['order_cancel_date'] = ''
# Get Timetable
logger_info.info('Get time table')
order_data['timetable'] = json.loads('[]')
result.set('upcoming_order', order_data)
# Check on first purchase
logger_info.info('Check first purchase')
first_order_count = Order.objects.filter(open_id=open_id, order_status__lte=10).count()
if first_order_count == 1:
hub_id = purchase_order.hub_id
event_order_service = EventOrderService(logger_info, logger_error)
event_order_service.create_event_order(0, hub_id, open_id, order_id)
else:
logger_error.error(order_serializer.errors)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Internal server error')
return Response(result.get_response(), result.get_code())
purchase_order.status = 1
purchase_order.save()
logger_info.info('Purchase order save')
# Product stock update
product_list = json.loads(purchase_order.product_list)
payload = {'trade_type': 0, 'product_list': product_list, 'validate_str': 'GoDbAcKeNdS'}
url = urlmapper.get_url('PRODUCT_STOCK')
response = requests.post(url, json=payload)
logger_info.info(response.text)
# Order complete
headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token}
payload = {'order_id': order_id}
url = urlmapper.get_url('OPERATION_ORDER_COMPLETE')
response = requests.post(url, headers=headers, json=payload)
logger_info.info(response.text)
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Internal server error')
return Response(result.get_response(), result.get_code())
# Step 6
# Save payment method and notify to admin server
# Upcoming order notification added
logger_info.info('Step 6')
headers = {'AUTHORIZATION': request.META['HTTP_AUTHORIZATION']}
payload = {'latest_payment_method': purchase_order.payment_type}
url = urlmapper.get_url('USER_INFO') + '/' + open_id + '/info'
response = requests.put(url, headers=headers, json=payload)
logger_info.info(response.json())
try:
# Hub message
logger_info.info('Hub message')
order_manager = OrderManager(logger_info, logger_error)
order_list_detail = order_manager.get_order_list(order_id)
payload = {
'code': 200, 'message': 'success', 'order': order_list_detail, 'type': 1,
'order_id': order_id, 'title': 'Here comes a new order'
}
url = urlmapper.get_url('HUB_MESSAGE_ANDROID')
response = requests.post(url, json=payload)
logger_info.info(response.text)
except Exception as e:
logger_info.info(str(e))
return Response(result.get_response(), result.get_code())