def delete(self, request, order_id):
# Request data parsing
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1]
logger_info.info(open_id + ':' + access_token + ':' + order_id)
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())
# Get purchase order instance
try:
order = Order.objects.get(open_id=open_id, order_id=order_id)
purchase_order = PurchaseOrder.objects.get(open_id=open_id, order_id=order.order_id)
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))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
# Check order status to edit
if order.order_status != 0:
error_code = code.ERROR_3009_ORDER_EDIT_NOT_AVAILABLE
logger_error.error(error_code)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
# Refund payment
header = {'open-id': open_id}
url = urlmapper.get_url('PAYMENT') + '/' + order_id + '/detail'
response = requests.delete(url, headers=header)
order.order_status = 11
order_history = json.loads(order.order_status_history)
order_history.append(dateformatter.get_order_status_history(11))
order.order_status_history = json.dumps(order_history)
order.operation_status = 10
order_operation_history = json.loads(order.operation_status_history)
order_operation_history.append(dateformatter.get_order_status_history(10))
order.operation_status_history = json.dumps(order_operation_history)
# Add order cancel date
order.order_cancel_date = datetime.today()
order.save()
if response.status_code != code.ARIES_200_SUCCESS:
purchase_order.status = 6
purchase_order.save()
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4003_PAYMENT_REFUND_FAIL))
result.set_error(code.ERROR_4003_PAYMENT_REFUND_FAIL)
return Response(result.get_response(), result.get_code())
else:
# Refund success
purchase_order.status = 5
purchase_order.save()
# Coupon restore
coupon_list = json.loads(purchase_order.coupon_list)
for coupon in coupon_list:
coupon_id = coupon['coupon_id']
coupon = CustomerCoupon.objects.get(id=coupon_id)
current_date = date.today()
if current_date <= coupon.end_date:
coupon.status = 0
coupon.used_date = current_date
coupon.save()
url = urlmapper.get_url('USER_NOTIFICATION') + '/coupon/0/1'
headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token}
requests.get(url, headers=headers)
else:
coupon.status = 2
coupon.used_date = current_date
coupon.save()
# Product stock update
product_list = json.loads(purchase_order.product_list)
payload = {'trade_type': 1, '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 canceled
headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token}
payload = {'order_id': order_id}
url = urlmapper.get_url('OPERATION_ORDER_CANCELED')
response = requests.post(url, headers=headers, json=payload)
logger_info.info(response.text)
# First purchase canceled
first_purchase_count = EventOrderHistory.objects.filter(open_id=open_id).count()
if first_purchase_count == 1:
first_purchase = EventOrderHistory.objects.get(open_id=open_id)
first_purchase.event_target = False
first_purchase.save()
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
return Response(result.get_response(), result.get_code())
def get(self, request, hub_id, date, table_id, shipping_type):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
target_db = 'default'
if request.META.get('HTTP_ACCEPT_LANGUAGE'):
accept_lang = request.META['HTTP_ACCEPT_LANGUAGE']
if 'zh' in accept_lang:
target_db = 'aries_cn'
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))
error_code = code.ERROR_3012_NOT_SUPPORT_DELIVERY_METHOD
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code))
result.set_error(code.ERROR_3012_NOT_SUPPORT_DELIVERY_METHOD)
return Response(result.get_response(), result.get_code())
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e))
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
return Response(result.get_response(), result.get_code())
# Default value
dlv_schedules = ''
try:
# print(str(date))
today = datetime.datetime.strptime(date, '%Y-%m-%d').date()
next_working_day = today + datetime.timedelta(days=30)
dlv_schedules = DeliverySchedule.objects.filter(working_day__range=[today, next_working_day])
shipping_avail = ShippingAvailability.objects.get(ds_id=dlv_schedules[0], hub_id=hub_id)
time_slots_avail = json.loads(shipping_avail.shipping_availability_table)
for target_slot in time_slots_avail:
if str(target_slot['index']) == table_id:
for target_slot_avail in target_slot['shipping']:
if str(target_slot_avail['shipping_type']) == shipping_type:
result.set('availability', target_slot_avail['available'])
result.set('delivery_start_time', target_slot['starttime'])
result.set('delivery_end_time', target_slot['endtime'])
return Response(result.get_response(), result.get_code())
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Invalid timetable index or shipping type')
result.set_error(code.ERROR_3007_DELIVERY_SCHEDULE_INVALID)
except DeliverySchedule.DoesNotExist:
print("No delivery schedule is found for date at {0},hub {1}".format(str(date), str(hub_id)))
error_code = code.ERROR_3011_NO_AVAILABLE_DELIVERY_SCHEDULE
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
except ShippingAvailability.DoesNotExist:
print("No shipping schedule is found for ds_id-{0},hub {1}".format(str(dlv_schedules.id), str(hub_id)))
error_code = code.ERROR_3011_NO_AVAILABLE_DELIVERY_SCHEDULE
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e))
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
return Response(result.get_response(), result.get_code())
def post(self, request, hub_id, time):
result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS)
logger_info.info(str(time))
lang_info = header_parser.parse_language_v2(request.META)
cn_header = lang_info.cn_header
target_db = lang_info.target_db
os_type = lang_info.os_type
try:
product_list = request.data['product_list']
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid')
return Response(result.get_response(), result.get_code())
product_manager = ProductManagerV3(logger_info, logger_error)
menu_manager = MenuManager(logger_info, logger_error)
restaurant_manager = RestaurantManager(logger_info, logger_error)
hub_manager = HubManagerV2(logger_info, logger_error)
product_list = hub_manager.get_product_list(product_list, hub_id)
stock_list = hub_manager.get_stock_list(hub_id, product_list,
target_db, os_type)
if len(stock_list) >= 1:
for product in stock_list:
# Get product data
product_data = product_manager.get_product_for_valid(
product['product_id'], cn_header)
# Set time bomb information
if 'time_bomb_info' in product:
product['time_bomb_info']['stock'] = product['stock']
product['time_bomb_info']['has_stock'] = True
product_data['price_discount'] = product['price_discount']
product_data['event_product'] = product['event_product']
product_data['price_discount_event'] = True
product['product'] = product_data
# Get menu data
menu_id = product_data['menu']
menu_data = menu_manager.get_menu_data(
target_db, menu_id, product_data['sales_time'], cn_header)
menu_data['review_statics'] = menu_manager.get_menu_statics(
menu_id)
menu_data[
'restaurant'] = restaurant_manager.get_restaurant_data(
menu_data['restaurant'], target_db)
product['product']['menu'] = menu_data
# Delete unusable field
del product['product_id']
del product['menu_id']
del product['prev_product_id']
result.set('product_list', stock_list)
else:
result.set('product_list', [])
return Response(result.get_response(), result.get_code())
def get(self, request, time_bomb_id):
lang_info = parse_language_v2(request.META)
lang_type = 1 if lang_info.cn_header else 0
cn_header = lang_info.cn_header
target_db = lang_info.target_db
os_type = lang_info.os_type
self.logger_info.info('os_type : ' + self.OS_TYPE[os_type])
try:
# Get time bomb data
time_bomb_manager = TimeBombManager(self.logger_info,
self.logger_error)
time_bomb = time_bomb_manager.get_time_bomb(
time_bomb_id, lang_type, os_type)
hub_id = time_bomb['hub']
# Default product list setting
product_list = []
# Get product data and check sold out
if time_bomb['status'] == self.STATUS_AVAILABLE:
product_manager = ProductManagerV3(self.logger_info,
self.logger_error)
product_id_list = time_bomb['products']
product_list = product_manager.get_product_list_from_ids(
product_id_list)
# Get menu id and check stock
stock_manager = StockManager(self.logger_info,
self.logger_error)
menu_id_list = [product['menu'] for product in product_list]
# Check if status is sold out or available
if stock_manager.check_sold_out(hub_id, menu_id_list):
time_bomb['status'] = self.STATUS_SOLD_OUT
# For menu data parsing
menu_manager = MenuManagerV2(self.logger_info,
self.logger_error)
# Discount information
discount_map = product_manager.get_time_bomb_discount_info(
time_bomb_id, product_id_list, cn_header)
# Stock information
stock_map = stock_manager.get_stock_map(hub_id, menu_id_list)
for product in product_list:
menu_manager.get_menu_data(product, target_db, cn_header)
if product['id'] in discount_map:
discount_info = discount_map[product['id']]
# Stock check
if product['menu']['id'] in stock_map:
discount_info['has_stock'] = True
discount_info['stock'] = stock_map[product['menu']
['id']]
add_discount_information(product, discount_info)
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
except Exception as e:
self.logger_info.info(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('status', time_bomb['status'])
result.set('products', product_list)
return Response(result.get_response(), result.get_code())
def post(self, request):
request_data = request.data
if request_data.get('notification_order'):
notification_order = request_data.get('notification_order')
else:
notification_order = False
logger_info.info('Payment Initation : ' + str(request_data))
try:
order_id = request_data['order_id']
payment_data = request_data['payment_raw_data']
payment_type = request_data['payment_type']
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid')
return Response(result.get_response(), result.get_code())
if payment_type == 0:
request_data['payment_raw_data'] = json.dumps(payment_data)
elif payment_type == 2 or payment_type == 3:
request_data['payment_raw_data'] = json.dumps(payment_data)
logger_info.info('Raw_Data : ' + str(request_data['payment_raw_data']))
# Check if the payment exists
payment_count = Payment.objects.filter(order_id=order_id).count()
if payment_count != 0:
payment = Payment.objects.get(order_id=order_id)
if payment.payment_status == 0 or payment.payment_status == 1:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
return Response(result.get_response(), result.get_code())
# Set payment status
request_data['payment_status'] = self.PAYMENT_CREATED
payment_serializer = PaymentSerializer(data=request_data)
if payment_serializer.is_valid():
payment_serializer.save()
payment = Payment.objects.get(order_id=order_id)
else:
print(payment_serializer.errors)
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid')
return Response(result.get_response(), result.get_code())
# Set alipay client
alipay_client = AliPay(
debug=settings.DEBUG,
appid=resources.get_alipay_app_id(),
app_notify_url=urlmapper.get_url('ALIPAY_CALLBACK_URL'),
app_private_key_path=resources.get_viastelle_pri_key(),
alipay_public_key_path=resources.get_viastelle_pub_key(),
sign_type='RSA2'
)
if payment_type == self.ALIPAY_APP_PAYMENT and not notification_order:
# RSA signing check for sync
alipay_app_result = payment_data['alipay_trade_app_pay_response']
sign = payment_data['sign']
content = json.loads(payment_data['content'])
sign_result = alipay_client.verify(content, sign)
response_code = int(alipay_app_result['code'])
alipay_app_result['order_id'] = order_id
alipay_app_result['alipay_trade_app_pay_response'] = content
alipay_app_result['alipay_trade_app_pay_validation'] = sign_result
serializer = AlipayPaymentSerializer(data=alipay_app_result)
if serializer.is_valid():
serializer.save()
else:
logger_info.info(serializer.errors)
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid')
return Response(result.get_response(), result.get_code())
# Check validation
if response_code == 10000:
payment.payment_status = 1
payment.save()
else:
payment.payment_status = 4
payment.save()
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4004_PAYMENT_INTERFACE_FAILED))
result.set_error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED)
return Response(result.get_response(), result.get_code())
elif payment_type == self.ALIPAY_MOBILE_PAYMENT or notification_order:
# Mobile payment
logger_info.info('MOBILE_PAYMENT' + str(payment_data))
# Query to alipay server
query_response = alipay_client.api_alipay_trade_query(
out_trade_no=order_id,
)
logger_info.info('-----------------')
logger_info.info(str(query_response))
payment_count = AlipayPaymentTransaction.objects.filter(out_trade_no=order_id).count()
if payment_count <= 0:
# Query response to AlipayPaymentSerializer
logger_info.info(type(payment_data))
alipay_payment = {
'alipay_trade_validation': False,
'code': query_response['code'],
'msg': query_response['msg'],
'app_id': payment_data['app_id'],
'charset': payment_data['charset'],
'out_trade_no': payment_data['out_trade_no'],
'seller_id': payment_data['seller_id'],
'timestamp': query_response['send_pay_date'],
'total_amount': payment_data['total_amount'],
'trade_no': payment_data['trade_no']
}
serializer = AlipayPaymentSerializer(data=alipay_payment)
if serializer.is_valid():
serializer.save()
else:
logger_info.info(serializer.errors)
query_count = AlipayQueryTransaction.objects.filter(order_id=order_id).count()
if query_count <= 0:
serializer = AlipayQuerySerializer(data=query_response)
query_response['order_id'] = order_id
if serializer.is_valid():
serializer.save()
else:
logger_info.info(serializer.errors)
logger_info.info('Before code == 10000')
if query_response['code'] == '10000':
payment.payment_status = 1
payment.save()
else:
payment.payment_status = 4
payment.save()
logger_error.error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4004_PAYMENT_INTERFACE_FAILED))
result.set_error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED)
return Response(result.get_response(), result.get_code())
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
return Response(result.get_response(), result.get_code())
def get(self, request):
# Response object
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
# Get access token
try:
access_token = str(
request.META['HTTP_AUTHORIZATION']).split(' ')[1]
api_request_util.get_admin_token_validate_v2(access_token)
hub_id = 1
delivery_schedule = int(request.GET.get('delivery_schedule'))
delivery_date = request.GET.get('delivery_date')
# Date information parsing
# Format : '2017-04-06'
target_date = datetime.strptime(delivery_date, '%Y-%m-%d').date()
except AuthInfoError:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Token or user not found')
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_error.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Bad request')
return Response(result.get_response(), result.get_code())
# Get order list
try:
order_list = list()
preparing_list = list()
if delivery_schedule <= 0:
orders = Order.objects.filter(
hub_id=hub_id, delivery_date=target_date).order_by('-id')
else:
orders = Order.objects.filter(
hub_id=hub_id,
delivery_date=target_date,
delivery_schedule=delivery_schedule).order_by('-id')
serializer = OrderListSerializer(orders, many=True)
order_data = serializer.data
for order in order_data:
order['order_status_history'] = json.loads(
order['order_status_history'])
order['operation_status_history'] = json.loads(
order['operation_status_history'])
order[
'delivery_schedule_time'] = product_util.get_delivery_schedule_str(
order['delivery_schedule'])
order_list.append(order)
if 1 <= order['operation_status'] <= 4:
preparing_list.append(order)
payload = {
'orders': order_list,
'preparing_orders': preparing_list
}
result.set('result', payload)
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())
def get(self, request):
print(request)
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
return Response(result.get_response(), result.get_code())
def operation(self, request):
path = request.path_info.split('/')
print(path)
for item in path:
if len(item) <= 0:
path.remove(item)
domain = path[0]
# Domain mapper
if self.mapper.get(domain):
domain_url = self.mapper.get(domain)
if request.path_info == '/products':
url = domain_url + request.path_info + '/'
else:
url = domain_url + request.path_info
else:
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'BAD REQUEST')
return Response(result.get_response(), result.get_code())
headers = {
'authorization': request.META.get('HTTP_AUTHORIZATION'),
'open-id': request.META.get('HTTP_OPEN_ID'),
'content-type': request.content_type,
'accept-language': request.META.get('HTTP_ACCEPT_LANGUAGE'),
'hub-id': request.META.get('HTTP_HUB_ID'),
'os-type': request.META.get('HTTP_OS_TYPE')
}
# Request section added
method = request.method.lower()
method_map = {
'get': requests.get,
'post': requests.post,
'put': requests.put,
'delete': requests.delete
}
for k, v in request.FILES.items():
request.data.pop(k)
# Query string parser
if method == 'get':
query_str = {}
for query_key in request.GET:
query_str[query_key] = request.GET[query_key]
if len(query_str) >= 1:
index = 0
url += '?'
for query_key in query_str.keys():
url = url + query_key + '=' + query_str[query_key]
if index < len(query_str) - 1:
url += '&'
index += 1
# Content type parse
if request.content_type and 'application/json' in request.content_type.lower(
):
data = json.dumps(request.data)
headers['content-type'] = request.content_type
response = method_map[method](url, headers=headers, data=data)
elif 'file' in request.FILES:
file = request.FILES['file']
files = {'file': file}
del headers['content-type']
response = method_map[method](url, headers=headers, files=files)
else:
data = request.data
response = method_map[method](url, headers=headers, data=data)
if response.headers.get('Content-Type',
'').lower() == 'application/json':
data = response.json()
else:
data = response.content
logger.info(
request.META.get('REMOTE_ADDR') + ' ' + str(response.status_code) +
' ' + request.path_info)
return Response(data=data, status=response.status_code)
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
lang_info = parse_language_v2(request.META)
logger_info.info(request_data)
try:
login_type = request_data['login_type']
login_key = request_data['login_key']
login_value = request_data['login_value']
login_sns_open_id = ''
login_sns_access_token = ''
login_sns_refresh_token = ''
login_type = int(login_type)
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())
# Mobile app/web: 0, QQ: 1, WeChat: 2, Password registration: 3
# Check sms verification & user count
if login_type == 0:
user_count = User.objects.filter(mdn=login_key).count()
# MDN is only one in member pool
if user_count >= 1:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_1005_USER_ALREADY_REGISTRATION))
result.set_error(code.ERROR_1005_USER_ALREADY_REGISTRATION)
logger_error.error(
get_msg(code.ERROR_1005_USER_ALREADY_REGISTRATION))
return Response(result.get_response(), result.get_code())
today = datetime.datetime.today()
sms_auth = SmsAuthHistory.objects.filter(
date=today, target_mdn=login_key).latest('id')
sms_auth_count = sms_auth.verification_count
if not sms_auth.has_verified or sms_auth_count > 3:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND))
result.set_error(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND)
logger_error.error(
get_msg(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND))
return Response(result.get_response(), result.get_code())
response = requests.get(
urlmapper.get_url('USER_SMS_VERIFICATION') + login_key)
if response.status_code != code.ARIES_200_SUCCESS:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND))
result.set_error(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND)
logger_error.error(
get_msg(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND))
return Response(result.get_response(), result.get_code())
# create open id
random_token = str(uuid.uuid4()).split('-')
open_id = str(random_token[0] + random_token[2] +
random_token[4]).upper()
# get token from server
if login_type is 0:
payload = {'user_open_id': open_id, 'user_account': login_key}
else:
payload = {
'user_open_id': open_id,
'user_account': login_sns_open_id
}
response = requests.post(urlmapper.get_url('PLATFORM_SERVER'),
json=payload)
if response.status_code == code.ARIES_200_SUCCESS:
response_json = response.json()
token = response_json['token']
token = str(token).upper()
else:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
'API connection fail')
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
logger_error.error(response.text)
return Response(result.get_response(), result.get_code())
# Sign-up user
if login_type is 0:
user_instance = User.objects.create(open_id=open_id,
mdn=login_key,
name=login_key,
mdn_verification=True,
access_token=token,
parent_type=0)
else:
user_instance = User.objects.create(open_id=open_id,
mdn='',
name=open_id[:6],
mdn_verification=False,
access_token=token)
UserLoginInfo.objects.create(
user=user_instance,
login_type=login_type,
login_key=login_key,
login_value=login_value,
login_sns_open_id=login_sns_open_id,
login_sns_access_token=login_sns_access_token,
login_sns_refresh_token=login_sns_refresh_token)
UserInfo.objects.create(user=user_instance, number_of_logon=0)
user_notify_info = UserNotifyInfo.objects.create(
user=user_instance)
UserGrade.objects.create(user=user_instance,
type=0,
extra_meal_point=0,
upgrade_date=datetime.datetime.now())
ShoppingBag.objects.create(user=user_instance, )
user_serializer = UserAccountSerializer(user_instance)
user_data = user_serializer.data
# User notify data
notify_info = UserNotifyInfo.objects.get(user=user_instance)
notify_info_serializer = UserNotifyInfoSerializer(notify_info)
notify_info_data = notify_info_serializer.data
del notify_info_data['id']
del notify_info_data['user']
user_data['notification_info'] = notify_info_data
# User grade data
user_grade = UserGrade.objects.get(user=user_instance)
grade_serializer = UserGradeSerializer(user_grade)
user_data['grade'] = grade_serializer.data
user_data['connection_account'] = json.loads(
user_data['connection_account'])
result.set('auto_registration', False)
result.set('user', user_data)
# If there is Member promotion, call member coupon interface
member_promo_result = request_member_promotion(
open_id, 0, lang_info.accept_lang)
result.set_map(member_promo_result)
logger_info.info('[views_sign][SignUp][post][' +
str(member_promo_result) + ']')
if member_promo_result['has_member_promotion']:
user_notify_info.has_new_coupon = True
user_notify_info.coupon_count = 1
user_notify_info.save()
# If there is a registration with referrer, update referrer count
if 'referrer_id' in request_data:
logger_info.info('[views_sign][SignUp][post][' +
'REFERRER SIGNUP' + ']')
user_mdn = user_instance.mdn
user_referral_service = UserReferralService(
logger_info, logger_error)
# Check if its mdn was used for registration before
registration_check = user_referral_service.read_user_referral_info_check(
user_mdn)
if registration_check:
share_id = request_data['referrer_id']
referrer_open_id = request_share_id_validation(share_id)
# Save User referral history
logger_info.info('[views_sign][SignUp][post][' +
str(open_id) + ']')
logger_info.info('[views_sign][SignUp][post][' +
str(user_mdn) + ']')
logger_info.info('[views_sign][SignUp][post][' +
str(share_id) + ']')
logger_info.info('[views_sign][SignUp][post][' +
str(referrer_open_id) + ']')
ref = user_referral_service.create_user_referral_info(
open_id, user_mdn, share_id, referrer_open_id)
logger_info.info('[views_sign][SignUp][post][' + str(ref) +
']')
user_service = UserService(logger_info, logger_error)
referrer_user = user_service.get_user_instance(
referrer_open_id)
referrer_notify_info = user_service.get_user_notify_info(
referrer_user)
referrer_notify_info.has_referral_event = True
referrer_notify_info.save()
logger_info.info(
'[views_sign][SignUp][post][Notification information saved]'
)
# Send notification
user_manager_v2 = UserManagerV2(logger_info, logger_error)
user_manager_v2.send_sign_up_push(referrer_open_id, True)
logger_info.info(
'[views_sign][SignUp][post][Send push completed]')
else:
logger_info.info(
'[views_sign][SignUp][post][Referral already registration.]'
)
# Change user info
user_info = UserInfo.objects.get(user=user_instance)
user_info.number_of_logon = F('number_of_logon') + 1
user_info.date_account_last_modified = datetime.datetime.now()
if 'os_type' in request_data:
if request_data['os_type'] == 0 or request_data['os_type'] == 1:
user_info.os_type = request_data['os_type']
user_info.save()
return Response(result.get_response(), status=result.get_code())
else:
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Sign up method not supported')
logger_info.info('Sign up method not supported')
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
logger_info.info(request.data)
serializer = UserLoginInfoSerializer(data=request.data)
if serializer.is_valid():
request_data = serializer.data
else:
logger_info.info(serializer.errors)
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'request data invalid')
return Response(result.get_response(), result.get_code())
try:
login_type = request_data['login_type']
if login_type == 0:
login_key = request_data['login_key']
login_info = UserLoginInfo.objects.filter(login_type=0,
login_key=login_key)
if login_info.count() >= 1:
login_info = UserLoginInfo.objects.get(login_type=0,
login_key=login_key)
else:
return Response(result.get_response(), result.get_code())
user = login_info.user
payload = {
'user_open_id': user.open_id,
'user_account': login_key
}
response = requests.delete(
urlmapper.get_url('PLATFORM_SERVER'), json=payload)
logger_info.info(response.text)
elif login_type == 1 or login_type == 4:
# QQ case
open_id = request_data['login_sns_open_id']
access_token = request_data['login_sns_access_token']
user = User.objects.get(open_id=open_id,
access_token=access_token)
login_info = UserLoginInfo.objects.filter(login_type=1,
user=user)
if login_info.count() >= 1:
login_info = UserLoginInfo.objects.get(login_type=1,
user=user)
user = login_info.user
payload = {
'user_open_id': user.open_id,
'user_account': login_info.login_sns_open_id
}
response = requests.delete(
urlmapper.get_url('PLATFORM_SERVER'), json=payload)
logger_info.info(response.text)
else:
# WeChat case
open_id = request_data['login_sns_open_id']
access_token = request_data['login_sns_access_token']
user = User.objects.get(open_id=open_id,
access_token=access_token)
login_info = UserLoginInfo.objects.filter(login_type=2,
user=user)
if login_info.count() >= 1:
login_info = UserLoginInfo.objects.get(login_type=2,
user=user)
user = login_info.user
payload = {
'user_open_id': user.open_id,
'user_account': login_info.login_sns_open_id
}
response = requests.delete(
urlmapper.get_url('PLATFORM_SERVER'), json=payload)
logger_info.info(response.text)
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_info.info(str(e))
return Response(result.get_response(), result.get_code())
def get(self, request, hub_id):
lang_info = parse_language_v2(request.META)
today = datetime.datetime.today()
try:
# Latest schedule
target_schedule = DeliverySchedule.objects.filter(
hub_id=int(hub_id)).latest('-id')
delivery_day = today
# After 9:00 pm, next day setting
if delivery_day.time() > target_schedule.delivery_end:
next_day = today + datetime.timedelta(days=1)
else:
next_day = today
time_slots = json.loads(target_schedule.delivery_time_table)
available_time = 0
matched_table = []
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:
table = {
'index': target_slot['index'],
'starttime': target_slot['starttime'],
'endtime': target_slot['endtime'],
'delivery_price': target_schedule.delivery_price
}
matched_table.append(table)
minimum_order_price = target_schedule.minimum_order_price
order_available = target_schedule.order_available
if lang_info.cn_header:
unavailable_msg = target_schedule.unavailable_msg_chn
else:
unavailable_msg = target_schedule.unavailable_msg_eng
if not order_available:
order_unavailable_msg = unavailable_msg
else:
order_unavailable_msg = ''
except Exception as e:
result = ResultResponse(code.ARIES_400_BAD_REQUEST, str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS_MSG)
result.set('working_day', next_day.strftime('%Y.%m.%d'))
result.set('timetable', matched_table)
result.set('order_available', order_available)
result.set('minimum_order_price', minimum_order_price)
result.set('order_unavailable_message', order_unavailable_msg)
return Response(result.get_response(), result.get_code())
def sign_up(self, login_type, request_data):
if login_type == QQ_APPLICATION:
login_key = request_data['login_sns_open_id']
login_sns_open_id = request_data['login_sns_open_id']
login_sns_access_token = request_data['login_sns_access_token']
# Auto sign-up section
login_value = ''
login_sns_refresh_token = ''
# create open id
random_token = str(uuid.uuid4()).split('-')
open_id = str(random_token[0] + random_token[2] + random_token[4]).upper()
# get token from server
payload = {'user_open_id': open_id, 'user_account': login_sns_open_id}
response = requests.post(urlmapper.get_url('PLATFORM_SERVER'), json=payload)
if response.status_code == code.ARIES_200_SUCCESS:
response_json = response.json()
token = response_json['token']
token = str(token).upper()
else:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'API connection fail')
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
logger_error.error(response.text)
return Response(result.get_response(), result.get_code())
# Sign-up user
user_instance = User.objects.create(
open_id=open_id,
mdn='',
name=open_id[:6],
mdn_verification=False,
access_token=token,
parent_type=QQ_APPLICATION
)
UserLoginInfo.objects.create(
user=user_instance,
login_type=QQ_APPLICATION,
login_key=login_key,
login_value=login_value,
login_sns_open_id=login_sns_open_id,
login_sns_access_token=login_sns_access_token,
login_sns_refresh_token=login_sns_refresh_token
)
UserInfo.objects.create(
user=user_instance,
number_of_logon=0
)
UserNotifyInfo.objects.create(
user=user_instance
)
UserGrade.objects.create(
user=user_instance,
type=0,
extra_meal_point=0,
upgrade_date=datetime.datetime.now()
)
ShoppingBag.objects.create(
user=user_instance,
)
user_notify_info = UserNotifyInfo.objects.get(user=user_instance)
user_notify_info.coupon_count = 1
user_notify_info.save()
# Connection information
user_instance.connection_count = F('connection_count') + 1
connect_info = json.loads(user_instance.connection_account)
connect_info.append({'login_type': QQ_APPLICATION, 'login_sns_open_id': login_sns_open_id})
user_instance.connection_account = json.dumps(connect_info)
user_instance.save()
login_info = UserLoginInfo.objects.get(login_sns_open_id=login_sns_open_id)
auto_registration = True
result = (login_info, login_sns_open_id, auto_registration)
elif login_type == WECHAT_APPLICATION or login_type == WECHAT_PUBLIC:
login_key = request_data['login_key']
login_value = request_data['login_value']
login_sns_open_id = request_data['login_sns_open_id']
login_sns_access_token = request_data['login_sns_access_token']
login_sns_refresh_token = request_data['login_sns_refresh_token']
# create open id
random_token = str(uuid.uuid4()).split('-')
open_id = str(random_token[0] + random_token[2] + random_token[4]).upper()
# get token from server
payload = {'user_open_id': open_id, 'user_account': login_sns_open_id}
response = requests.post(urlmapper.get_url('PLATFORM_SERVER'), json=payload)
if response.status_code == code.ARIES_200_SUCCESS:
response_json = response.json()
token = response_json['token']
token = str(token).upper()
else:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'API connection fail')
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
logger_error.error(response.text)
return Response(result.get_response(), result.get_code())
# Sign-up user
user_instance = User.objects.create(
open_id=open_id,
mdn='',
name=open_id[:6],
mdn_verification=False,
access_token=token,
parent_type=WECHAT_APPLICATION
)
UserLoginInfo.objects.create(
user=user_instance,
login_type=WECHAT_APPLICATION,
login_key=login_key,
login_value=login_value,
login_sns_open_id=login_sns_open_id,
login_sns_access_token=login_sns_access_token,
login_sns_refresh_token=login_sns_refresh_token
)
UserInfo.objects.create(
user=user_instance,
number_of_logon=0
)
UserNotifyInfo.objects.create(
user=user_instance
)
UserGrade.objects.create(
user=user_instance,
type=0,
extra_meal_point=0,
upgrade_date=datetime.datetime.now()
)
ShoppingBag.objects.create(
user=user_instance,
)
user_notify_info = UserNotifyInfo.objects.get(user=user_instance)
user_notify_info.coupon_count = 1
user_notify_info.save()
# Connection information
user_instance.connection_count = F('connection_count') + 1
connect_info = json.loads(user_instance.connection_account)
connect_info.append({'login_type': WECHAT_APPLICATION,
'login_sns_open_id': login_sns_open_id})
user_instance.connection_account = json.dumps(connect_info)
user_instance.save()
login_info = UserLoginInfo.objects.get(login_sns_open_id=login_sns_open_id)
result = (login_info, login_sns_open_id, True)
elif login_type == QQ_MOBILE:
login_key = request_data['login_key']
login_value = request_data['login_value']
login_sns_open_id = request_data['login_sns_open_id']
login_sns_access_token = request_data['login_sns_access_token']
login_sns_refresh_token = request_data['login_sns_refresh_token']
# create open id
random_token = str(uuid.uuid4()).split('-')
open_id = str(random_token[0] + random_token[2] + random_token[4]).upper()
# get token from server
payload = {'user_open_id': open_id, 'user_account': login_sns_open_id}
response = requests.post(urlmapper.get_url('PLATFORM_SERVER'), json=payload)
if response.status_code == code.ARIES_200_SUCCESS:
response_json = response.json()
token = response_json['token']
token = str(token).upper()
else:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'API connection fail')
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
logger_error.error(response.text)
return Response(result.get_response(), result.get_code())
# Sign-up user
user_instance = User.objects.create(
open_id=open_id,
mdn='',
name=open_id[:6],
mdn_verification=False,
access_token=token,
parent_type=QQ_APPLICATION
)
UserLoginInfo.objects.create(
user=user_instance,
login_type=QQ_APPLICATION,
login_key=login_key,
login_value=login_value,
login_sns_open_id=login_sns_open_id,
login_sns_access_token=login_sns_access_token,
login_sns_refresh_token=login_sns_refresh_token
)
UserInfo.objects.create(
user=user_instance,
number_of_logon=0
)
UserNotifyInfo.objects.create(
user=user_instance
)
UserGrade.objects.create(
user=user_instance,
type=0,
extra_meal_point=0,
upgrade_date=datetime.datetime.now()
)
ShoppingBag.objects.create(
user=user_instance,
)
user_notify_info = UserNotifyInfo.objects.get(user=user_instance)
user_notify_info.coupon_count = 1
user_notify_info.save()
# Connection information
user_instance.connection_count = F('connection_count') + 1
connect_info = json.loads(user_instance.connection_account)
connect_info.append({'login_type': QQ_APPLICATION,
'login_sns_open_id': login_sns_open_id})
user_instance.connection_account = json.dumps(connect_info)
user_instance.save()
login_info = UserLoginInfo.objects.get(login_sns_open_id=login_sns_open_id)
result = (login_info, login_sns_open_id, True)
elif login_type == MDN_QUICK:
login_type = request_data['login_type']
login_key = request_data['login_key']
login_value = ''
login_sns_open_id = ''
login_sns_access_token = ''
login_sns_refresh_token = ''
# create open id
random_token = str(uuid.uuid4()).split('-')
open_id = str(random_token[0] + random_token[2] + random_token[4]).upper()
# get token from server
payload = {'user_open_id': open_id, 'user_account': login_key}
response = requests.post(urlmapper.get_url('PLATFORM_SERVER'), json=payload)
if response.status_code == code.ARIES_200_SUCCESS:
response_json = response.json()
token = response_json['token']
token = str(token).upper()
else:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'API connection fail')
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
logger_error.error(response.text)
return Response(result.get_response(), result.get_code())
# Sign-up user
user_instance = User.objects.create(
open_id=open_id,
mdn=login_key,
name=login_key,
mdn_verification=True,
access_token=token,
parent_type=MDN_QUICK
)
UserLoginInfo.objects.create(
user=user_instance,
login_type=login_type,
login_key=login_key,
login_value=login_value,
login_sns_open_id=login_sns_open_id,
login_sns_access_token=login_sns_access_token,
login_sns_refresh_token=login_sns_refresh_token
)
UserInfo.objects.create(
user=user_instance,
number_of_logon=0
)
UserNotifyInfo.objects.create(
user=user_instance
)
UserGrade.objects.create(
user=user_instance,
type=0,
extra_meal_point=0,
upgrade_date=datetime.datetime.now()
)
ShoppingBag.objects.create(
user=user_instance,
)
user_notify_info = UserNotifyInfo.objects.get(user=user_instance)
user_notify_info.coupon_count = 1
user_notify_info.save()
# Change user info
user_info = UserInfo.objects.get(user=user_instance)
user_info.number_of_logon = F('number_of_logon') + 1
user_info.date_account_last_modified = datetime.datetime.now()
if 'os_type' in request_data:
if request_data['os_type'] == 0 or request_data['os_type'] == 1:
user_info.os_type = request_data['os_type']
user_info.save()
user_login_info = UserLoginInfo.objects.get(login_key=login_key)
result = (user_login_info, login_key, True)
else:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'NOT SUPPORT LOGIN TYPE')
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
return Response(result.get_response(), result.get_code())
return result
def get(self, request, time_bomb_id):
lang_info = parse_language_v2(request.META)
lang_type = 1 if lang_info.cn_header else 0
cn_header = lang_info.cn_header
target_db = lang_info.target_db
os_type = lang_info.os_type
self.logger_info.info('os_type : ' + self.OS_TYPE[os_type])
try:
# Get time bomb data
time_bomb_manager = TimeBombManager(self.logger_info,
self.logger_error)
time_bomb_exists = time_bomb_manager.check_time_bomb_exists(
time_bomb_id)
# Default product list setting
product_list = []
if time_bomb_exists:
time_bomb = time_bomb_manager.get_time_bomb(
time_bomb_id, lang_type, os_type)
hub_id = time_bomb['hub']
# Get product data and check sold out
if time_bomb['status'] == self.STATUS_AVAILABLE:
product_manager = ProductManagerV3(self.logger_info,
self.logger_error)
product_id_list = time_bomb['products']
product_list = product_manager.get_product_list_from_ids(
product_id_list)
# Get menu id and check stock
stock_manager = StockManager(self.logger_info,
self.logger_error)
menu_id_list = [
product['menu'] for product in product_list
]
# Check if status is sold out or available
if stock_manager.check_sold_out(hub_id, menu_id_list):
time_bomb['status'] = self.STATUS_SOLD_OUT
# For menu data parsing
menu_manager = MenuManagerV2(self.logger_info,
self.logger_error)
# Discount information
discount_map = product_manager.get_time_bomb_discount_info(
time_bomb_id, product_id_list, cn_header)
# Stock information
stock_map = stock_manager.get_stock_map(
hub_id, menu_id_list)
for product in product_list:
menu_manager.get_menu_data(product, target_db,
cn_header)
if product['id'] in discount_map:
discount_info = discount_map[product['id']]
# Stock check
if product['menu']['id'] in stock_map:
discount_info['has_stock'] = True
discount_info['stock'] = stock_map[
product['menu']['id']]
add_discount_information(product, discount_info)
else:
# Time bomb expired template
if cn_header:
time_bomb = time_bomb_expired_template_cn()
else:
time_bomb = time_bomb_expired_template_en()
# Add action template
# time_bomb_url = 'https://m.viastelle.com/#/promotions/timeBombInt'
extra = {
'share_image':
'',
'share_title':
'',
'share_description':
'',
'share_enable':
False,
'link':
'https://stg-cli.viastelle.com/dist/#/promotions/timeBombInt'
}
if cn_header:
extra['title'] = '推广'
else:
extra['title'] = 'PROMOTION'
action_object = {
'action_type': 13,
'action_target':
'https://stg-cli.viastelle.com/dist/#/promotions/timeBombInt',
'action_extra': json.dumps(extra)
}
# Stock api call interval
api_call_interval = 60
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
except Exception as e:
self.logger_info.info(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set_map(time_bomb)
result.set('action', action_object)
result.set('stock_api_interval', api_call_interval)
result.set('products', 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
self.logger_info.info(request_data)
auth_info = header_parser.parse_auth_info(request)
lang_info = parse_language_v2(request.META)
open_id = auth_info.open_id
access_token = auth_info.access_token
cn_header = lang_info.cn_header
accept_lang = lang_info.accept_lang
os_type = lang_info.os_type
hub_id = request_data.get('hub_id', 1)
try:
# Order reserve manager
reserve_manager = OrderReserveManager(self.logger_info, self.logger_error, request_data)
# Request data validation
request_validation(open_id, access_token, request_data)
# Request product validation
validation_result = purchase_validation(accept_lang, request_data, os_type)
# Product check
valid_result = reserve_manager.product_validation(validation_result, cn_header)
# Sales time check
delivery_time_result = reserve_manager.delivery_time_validation(valid_result, accept_lang,
os_type, hub_id)
# Product detail setting
product_list = reserve_manager.set_product_detail(delivery_time_result)
# Delivery detail check
reserve_manager.set_delivery_detail(lang_info.cn_header)
# Coupon business logic process, product list from sales_time_response
coupon_list = request_data['coupon_list']
coupon_manager = CouponManagerV2(self.logger_info, self.logger_error)
coupon_manager.coupon_validate(auth_info.open_id, product_list, coupon_list)
# Calculate total price
coupon_detail = coupon_manager.get_coupon_detail()
discount_amount = -coupon_manager.get_discount_price()
reserve_manager.set_total_price(coupon_detail, discount_amount, open_id)
# Set misc parameters
reserve_manager.set_misc_params()
# Get payment params from payment parameter factory
param_result = reserve_manager.get_payment_param(cn_header)
payment_param_factory = PayParamInstance.factory(param_result[0], self.logger_info, self.logger_error)
payment_params = payment_param_factory.get_payment_params(param_result[1])
for key in payment_params.keys():
result.set(key, payment_params[key])
# Save purchase order object to database
order_id = reserve_manager.save_purchase_order()
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message, err_code)
except AuthInfoError:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authentication error')
except BusinessLogicError as instance:
message, err_code, data_set = instance.args
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, message, err_code)
result.set_map(data_set)
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e))
else:
result.set('order_id', order_id)
return Response(result.get_response(), result.get_code())
def post(self, request, hub_id=1):
try:
request_data = request.data
request_validation(request_data)
menu_id_list = request_data['menu_id_list']
target_db = request_data['target_db']
cn_header = False if target_db == 'default' else True
sales_time_str = get_sales_time_str()
date_info = get_date_information_v2(hub_id, sales_time_str)
lang_info = parse_language_v2(request.META)
os_type = lang_info.os_type
product_manager = ProductManagerV3(self.logger_info,
self.logger_error)
product_data = product_manager.get_product_info(
hub_id, menu_id_list)
menu_manager = MenuManagerV2(self.logger_info, self.logger_error)
product_list = []
for product in product_data:
product_list.append(
menu_manager.get_menu_data(product, target_db, cn_header))
# Check the current available time bomb
time_bomb_manager = TimeBombManager(self.logger_info,
self.logger_error)
time_bomb_id = time_bomb_manager.get_time_bomb_now(hub_id, os_type)
# Get time bomb information
if time_bomb_id is not None:
discount_map = product_manager.get_all_discount_info(
time_bomb_id, cn_header)
for product in product_list:
if product['id'] in discount_map:
discount_info = discount_map[product['id']]
add_discount_information(product, discount_info)
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
except Exception as e:
self.logger_info.info(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS_MSG)
result.set('products', product_list)
result.set('hub_id', int(hub_id))
result.set('time_type', date_info.time_type)
result.set('phase_next_day', date_info.phase_next_day)
result.set('phase_date', date_info.current_date.isoformat())
result.set('order_available',
product_util.get_available_time(date_info.time_type))
return Response(result.get_response(), result.get_code())
def post(self, request, folder_name):
print(request.META)
print(request.FILES)
result = ResultResponse(code.ARIES_200_SUCCESS, 'Upload success')
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(
request.META['HTTP_AUTHORIZATION']).split(' ')[1]
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Token or open id invalid')
return Response(result.get_response(), result.get_code())
if 'file' in request.FILES:
# File object create
file = request.FILES['file']
fs = FileSystemStorage()
filename = fs.save(file.name, file)
# File size check
file_size = file.size
if file_size >= self.MEGA * 5:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_1102_FILE_OVERSIZE))
result.set_error(code.ERROR_1102_FILE_OVERSIZE)
return Response(result.get_response(), result.get_code())
# File name information processing
uploaded_file_url = fs.path(filename)
upload_filename = self.make_file_name(filename)
upload_file_ext = filename.split('.')[-1]
upload_name = folder_name + '/' + upload_filename
print(upload_name)
# Check file format to png or jpg
if upload_file_ext.lower() != 'png' and upload_file_ext.lower() != 'jpg'\
and upload_file_ext.lower() != 'jpeg':
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL))
result.set_error(code.ERROR_1101_NOT_SUPPORTED_FILE_FORMAT)
print('Error')
fs.delete(filename)
return Response(result.get_response(), result.get_code())
url = 'http://viastelle-user-storage.oss-cn-shanghai.aliyuncs.com/' + upload_name
host = 'viastelle-user-storage.oss-cn-shanghai.aliyuncs.com'
hash_value = hashlib.md5()
with open(uploaded_file_url, 'rb') as mdfile:
for buf in iter(partial(mdfile.read, 128), b''):
hash_value.update(buf)
content_md5 = base64.b64encode(hash_value.digest()).decode('utf-8')
headers = {
'Content-MD5':
content_md5,
'Content-Length':
str(file_size),
'Content-Type':
'image/' + upload_file_ext,
'Host':
host,
'Date':
oss.get_gmt_date(),
'Authorization':
oss.get_oss_header(
upload_filename, 'PUT', content_md5, upload_file_ext,
'/viastelle-user-storage/' + folder_name + '/')
}
with open(uploaded_file_url, 'rb') as upload_file:
data = upload_file.read()
response = requests.put(url, headers=headers, data=data)
if response.status_code is 200:
result.set('file_name', upload_name)
# Check profile image
if folder_name.lower() == 'profile':
url = urlmapper.get_url(
'USER_INFO') + '/' + open_id + '/detail'
headers = {
'AUTHORIZATION': 'bearer ' + access_token,
'OPEN-ID': open_id
}
payload = {'profile_image': upload_name}
user_response = requests.put(url,
headers=headers,
json=payload)
print(user_response.text)
else:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
"File upload fail")
fs.delete(filename)
else:
print('no file!!')
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
"File upload fail")
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
# Request data parsing
try:
request_data = request.data
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())
# Set alipay client
alipay_client = AliPay(
debug=settings.DEBUG,
appid=resources.get_alipay_app_id(),
app_notify_url=urlmapper.get_url('ALIPAY_CALLBACK_URL'),
app_private_key_path=resources.get_viastelle_pri_key(),
alipay_public_key_path=resources.get_viastelle_pub_key(),
sign_type='RSA2'
)
# Notification verification from ALIPAY
noti_origin_data = json.dumps(request_data)
noti_data = json.loads(noti_origin_data)
sign = noti_data.pop('sign')
sign_type = noti_data['sign_type']
trade_status = noti_data['trade_status']
verify_result = alipay_client.verify(noti_data, sign)
logger_info.info('[notification_data]:' + noti_origin_data)
logger_info.info(verify_result)
if not verify_result:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4004_PAYMENT_INTERFACE_FAILED))
result.set_error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED)
return Response(result.get_response(), result.get_code())
# Check the order exists
try:
order_id = noti_data['out_trade_no']
noti_data['order_id'] = order_id
noti_data['sign'] = sign
noti_data['sign_type'] = sign_type
noti_data['alipay_notification_validation'] = verify_result
order_count = Order.objects.filter(order_id=order_id).count()
purchase_order_count = PurchaseOrder.objects.filter(order_id=order_id).count()
if order_count == 0 and purchase_order_count == 1 and trade_status == 'TRADE_SUCCESS':
# Order has not created
purchase_order = PurchaseOrder.objects.get(order_id=order_id)
open_id = purchase_order.open_id
url = urlmapper.get_url('USER_PAYMENT_TOKEN')
payload = {
'open_id': purchase_order.open_id
}
response = requests.post(url, json=payload)
if response.status_code == 200:
response_json = response.json()
access_token = response_json['access_token']
else:
return Response(result.get_response, result.get_code())
url = urlmapper.get_url('ORDER')
headers = {
'open-id': open_id,
'authorization': 'bearer ' + access_token
}
payload = {
'order_id': order_id,
'payment_type': self.ALIPAY_MOBILE_PAYMENT,
'payment_data': noti_data,
'alipay_notification_order': True
}
response = requests.post(url, headers=headers, json=payload)
logger_info.info(response.text)
notification_count = AlipayNotification.objects.filter(
order_id=order_id
).count()
if notification_count == 0:
serializer = AlipayNotificationSerializer(data=noti_data)
else:
notification_instance = AlipayNotification.objects.get(order_id=order_id)
serializer = AlipayNotificationSerializer(notification_instance, data=noti_data, partial=True)
if serializer.is_valid():
serializer.save()
else:
logger_info.info(serializer.errors)
except Exception as e:
logger_info.info(str(e))
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())
def put(self, request, order_id):
request_data = request.data
logger_info.info(request_data)
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
try:
access_token = str(
request.META['HTTP_AUTHORIZATION']).split(' ')[1]
api_request_util.get_admin_token_validate_v2(access_token)
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Authentication error')
return Response(result.get_response(), result.get_code())
# Change order data
try:
order = Order.objects.get(order_id=order_id)
"""
order.order_status = 11
order_history = json.loads(order.order_status_history)
order_history.append(self.get_order_status_history(11))
order.order_status_history = json.dumps(order_history)
order.operation_status = 10
order_operation_history = json.loads(order.operation_status_history)
order_operation_history.append(self.get_order_status_history(10))
order.operation_status_history = json.dumps(order_operation_history)
"""
# Do business logic to each status
change_status = request_data['operation_status']
if change_status == 1:
logger_info.info('start packaging')
if order.order_status == 0:
order_history = json.loads(order.order_status_history)
order_history.append(
dateformatter.get_order_status_history(1))
request_data['order_status'] = 1
request_data['order_status_history'] = json.dumps(
order_history)
if order.operation_status == 0:
order_operation_history = json.loads(
order.operation_status_history)
order_operation_history.append(
dateformatter.get_order_status_history(1))
request_data['operation_status'] = 1
request_data['order_operation_history'] = json.dumps(
order_operation_history)
elif change_status == 2:
logger_info.info('Packaging done')
if order.operation_status == 1:
order_operation_history = json.loads(
order.operation_status_history)
order_operation_history.append(
dateformatter.get_order_status_history(2))
request_data['operation_status'] = 2
request_data['order_operation_history'] = json.dumps(
order_operation_history)
elif change_status == 5:
logger_info.info('Delivery started')
if order.order_status == 1:
order_history = json.loads(order.order_status_history)
order_history.append(
dateformatter.get_order_status_history(2))
request_data['order_status'] = 2
request_data['order_status_history'] = json.dumps(
order_history)
if order.operation_status == 2:
order_operation_history = json.loads(
order.operation_status_history)
order_operation_history.append(
dateformatter.get_order_status_history(3))
request_data['operation_status'] = 5
request_data['order_operation_history'] = json.dumps(
order_operation_history)
elif change_status == 6:
logger_info.info('Delivery completed')
if order.order_status == 2:
order_history = json.loads(order.order_status_history)
order_history.append(
dateformatter.get_order_status_history(10))
request_data['order_status'] = 10
request_data['order_status_history'] = json.dumps(
order_history)
if order.operation_status == 5:
order_operation_history = json.loads(
order.operation_status_history)
order_operation_history.append(
dateformatter.get_order_status_history(6))
request_data['operation_status'] = 6
request_data['order_operation_history'] = json.dumps(
order_operation_history)
serializer = OrderSerializer(order,
data=request_data,
partial=True)
if serializer.is_valid():
serializer.save()
order_data = serializer.data
result.set('result', order_data)
purchase_order = order.purchase_order
order_data['order_status_history'] = json.loads(
order_data['order_status_history'])
order_data['operation_status_history'] = json.loads(
order_data['operation_status_history'])
order_data['order_details'] = json.loads(
purchase_order.order_details)
order_data[
'special_instruction'] = purchase_order.special_instruction
order_data['extra_telephone'] = purchase_order.extra_telephone
# price information
order_data['price_sub_total'] = purchase_order.price_sub_total
order_data[
'price_delivery_fee'] = purchase_order.price_delivery_fee
order_data['price_discount'] = purchase_order.price_discount
order_data['price_total'] = purchase_order.price_total
# Address information (Please check after purchase order model update)
order_data['address_id'] = purchase_order.delivery_address_id
del order_data['purchase_order']
result.set('order', order_data)
else:
logger_info.info(serializer.errors)
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid')
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())
def get(self, request, order_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1]
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())
lang_info = header_parser.parse_language_v2(request.META)
accept_lang = lang_info.accept_lang
os_type = lang_info.os_type
# Check order_id length
if len(order_id) < 17:
logger_error.error(code.ERROR_9001_PARAMETER_VALIDATION_FAILED)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_9001_PARAMETER_VALIDATION_FAILED))
result.set_error(code.ERROR_9001_PARAMETER_VALIDATION_FAILED)
return Response(result.get_response(), result.get_code())
# Request data parsing
try:
order = Order.objects.get(open_id=open_id, order_id=order_id)
purchase_order = PurchaseOrder.objects.get(order_id=order.order_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']
if purchase_order_data['extra_telephone'] is None:
purchase_order_data['extra_telephone'] = ''
if purchase_order_data['special_instruction'] is None:
purchase_order_data['special_instruction'] = ''
order_serializer = UpcomingOrderSerializer(order)
order_data = order_serializer.data
order_data['purchase_order'] = purchase_order_data
start_date = order.order_start_date.strftime(resources.DATE_WITH_AM_PM)
order_data['order_start_date'] = dateformatter.get_yymmdd_time(start_date)
del order_data['order_status_history']
if order.order_status == 11:
order_cancel_date = order.order_cancel_date
if order_cancel_date is not None:
order_cancel_date = order.order_cancel_date.strftime(resources.DATE_WITH_AM_PM)
order_data['order_cancel_date'] = dateformatter.get_yymmdd_time(order_cancel_date)
else:
order_data['order_cancel_date'] = ''
else:
order_data['order_cancel_date'] = ''
result.add(order_data)
product_list = json.loads(purchase_order.product_list)
headers = {'accept-language': accept_lang}
json_data = {
'product_list': product_list,
'open_id': open_id,
'order_id': order_id,
'hub_id': purchase_order_data['hub_id']
}
response = requests.post(urlmapper.get_url('MENU_VALIDATE'), headers=headers, json=json_data)
response_json = response.json()
result.set('reviews', response_json['reviews'])
result.set('review_items', response_json['review_items'])
except Exception as e:
logger_info.info(str(e))
print(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid')
return Response(result.get_response(), result.get_code())
# Get user default hub id
user_information = api_request_util.get_user_information(open_id, access_token)
hub_id = user_information[1]['user']['default_hub_id'] if user_information[0] else 1
# Recommend product list
product_list = api_request_util.get_recommend_products(accept_lang, hub_id, os_type)
result.set('products', product_list)
return Response(result.get_response(), result.get_code())
def get(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
try:
access_token = str(
request.META['HTTP_AUTHORIZATION']).split(' ')[1]
api_request_util.get_admin_token_validate_v2(access_token)
order_id = request.GET.get('order_id')
name = request.GET.get('name')
mdn = request.GET.get('mdn')
open_id = request.GET.get('open_id')
page = int(request.GET.get('page'))
limit = int(request.GET.get('limit'))
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Authentication error')
return Response(result.get_response(), result.get_code())
# Execute query
try:
request_str = {
'order_id__icontains': order_id,
'user_name__icontains': name,
'user_telephone__icontains': mdn,
'open_id__icontains': open_id
}
query_str = request_str.copy()
for item in request_str.keys():
if request_str[item] is None:
query_str.pop(item)
logger_info.info(query_str)
order_list = list()
orders = Order.objects.filter(**query_str)
order_count = orders.count()
paginator = Paginator(orders, limit)
order_objects = paginator.page(page).object_list
serializer = OrderListSerializer(order_objects, many=True)
order_data = serializer.data
for order in order_data:
order['order_status_history'] = json.loads(
order['order_status_history'])
order['operation_status_history'] = json.loads(
order['operation_status_history'])
order['order_start_date'] = order[
'order_start_date'][:19].replace('T', ' ')
order[
'delivery_schedule_time'] = product_util.get_delivery_schedule_str(
order['delivery_schedule'])
order_list.append(order)
result_json = {'total_count': order_count, 'orders': order_list}
result.set('result', result_json)
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Bad request')
return Response(result.get_response(), result.get_code())
def put(self, request, order_id):
logger_info.info(order_id)
request_data = request.data
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
# Request data parsing
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1]
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())
# Get purchase order instance
try:
order = Order.objects.get(open_id=open_id, order_id=order_id)
purchase_order = PurchaseOrder.objects.get(open_id=open_id, order_id=order.order_id)
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))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
# Check order status to edit
if order.order_status != 0:
error_code = code.ERROR_3009_ORDER_EDIT_NOT_AVAILABLE
logger_error.error(error_code)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
# Applying changed items to purchase order information
try:
# Check delivery schedule
original_schedule = purchase_order.delivery_schedule
new_schedule = request_data['delivery_schedule']
if original_schedule != request_data['delivery_schedule']:
hub_id = purchase_order.hub_id
delivery_date = str(purchase_order.delivery_date)[:10]
method = purchase_order.shipping_method
if purchase_order.delivery_on_site:
method = 1
query_str = '/' + str(hub_id) + '/' + delivery_date + '/' + str(new_schedule) + '/' + str(method)
url = urlmapper.get_url('TIMETABLE_LIST') + query_str
response = requests.get(url)
response_json = response.json()
if response.status_code != code.ARIES_200_SUCCESS:
api_result = response.json()
result = ResultResponse(api_result['code'],
api_result['message'])
result.set_error(api_result['error_code'])
return Response(result.get_response(), result.get_code())
if response_json['availability']:
start_time = response_json['delivery_start_time']
end_time = response_json['delivery_end_time']
request_data['delivery_start_time'] = start_time
request_data['delivery_end_time'] = end_time
if start_time[1:2] == '0':
start_time_prefix = start_time[:2]
start_time_postfix = start_time[2:]
else:
start_time_prefix = start_time[:1]
start_time_postfix = start_time[1:]
if end_time[1:2] == '0':
end_time_prefix = end_time[:2]
end_time_postfix = end_time[2:]
else:
end_time_prefix = end_time[:1]
end_time_postfix = end_time[1:]
post_str = start_time_prefix + start_time_postfix + '-' + end_time_prefix + end_time_postfix
order.delivery_time = order.delivery_time[:12] + post_str
order.delivery_schedule = new_schedule
order.save()
else:
error_code = code.ERROR_3007_DELIVERY_SCHEDULE_INVALID
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(error_code))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
# Check Address information
old_address_id = purchase_order.delivery_address_id
new_address_id = request_data['delivery_address_id']
if old_address_id != new_address_id:
# Check if hub_id was changed
product_list = json.loads(purchase_order.product_list)
payload = {'product_list': product_list, 'delivery_schedule': new_schedule}
response = requests.post(urlmapper.get_url('PRODUCT_VALIDATION'), json=payload)
if response.status_code == code.ARIES_200_SUCCESS:
response_json = response.json()
else:
logger_error.error(response.text)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
code.ERROR_9000_INTERNAL_API_CALL_FAILED)
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
return Response(result.get_response(), result.get_code())
# Product validation check
product_count = response_json['product_count']
if product_count != len(product_list):
logger_error.error(code.ERROR_3010_DELIVERY_CHANGE_NOT_ALLOWED)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
code.ERROR_3010_DELIVERY_CHANGE_NOT_ALLOWED)
result.set_error(code.ERROR_3010_DELIVERY_CHANGE_NOT_ALLOWED)
return Response(result.get_response(), result.get_code())
# If product is valid, change product stock and more address change business logic
# TBD
headers = {'open-id': str(open_id), 'authorization': 'bearer ' + access_token}
response = requests.get(urlmapper.get_url('PRODUCT_ADDRESS_DETAIL') + '/' +
str(new_address_id), headers=headers)
if response.status_code == code.ARIES_200_SUCCESS:
response_json = response.json()
else:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
code.ERROR_9000_INTERNAL_API_CALL_FAILED)
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
return Response(result.get_response(), result.get_code())
# Register address to database
address = response_json['user_address']
order.delivery_address = address['name'] + ' ' + address['detail']
order.save()
request_data['delivery_address_id'] = new_address_id
order_serializer = PurchaseOrderSerializer(purchase_order, data=request_data, partial=True)
if order_serializer.is_valid():
order_serializer.save()
purchase_order = PurchaseOrder.objects.get(id=order_serializer.data['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_serializer = UpcomingOrderSerializer(order)
order_data = order_serializer.data
order_start_date = datetime.strptime((str(order.order_start_date)[:-10]), '%Y-%m-%d %H:%M')
order_data['order_start_date'] = order_start_date.strftime('%Y-%m-%d %I:%M %p')
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_status = order_data['order_status']
if order_status == 0:
hub_id = purchase_order.hub_id
sales_time = product_util.get_sales_time_to_str(purchase_order.sales_time)
response = requests.get(urlmapper.get_time_table_url(hub_id, sales_time))
response_json = response.json()
order_data['timetable'] = response_json['timetable']
else:
order_data['timetable'] = json.loads('[]')
result.set('upcoming_order', order_data)
else:
logger_info.info(order_serializer.errors)
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid')
return Response(result.get_response(), result.get_code())
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())
return Response(result.get_response(), result.get_code())
def delete(self, request, order_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
logger_info.info(request_data)
# Request data parsing
try:
open_id = request.META['HTTP_OPEN_ID']
payment = Payment.objects.get(open_id=open_id, order_id=order_id)
except Exception as e:
logger_error.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid')
return Response(result.get_response(), result.get_code())
payment_type = payment.payment_type
# Refund business logic
if payment_type == 0 or payment_type == 2:
alipay_transaction = AlipayPaymentTransaction.objects.get(
out_trade_no=order_id)
# Check debug state value
if settings.STAGE or settings.DEBUG:
debug = True
else:
debug = False
alipay = AliPay(
appid=resources.get_alipay_app_id(),
app_notify_url=resources.get_alipay_notify_url(),
app_private_key_path=resources.get_viastelle_pri_key(),
alipay_public_key_path=resources.get_viastelle_pub_key(),
sign_type='RSA2',
debug=debug)
refund_result = alipay.api_alipay_trade_refund(
out_trade_no=alipay_transaction.out_trade_no,
trade_no=alipay_transaction.trade_no,
refund_amount=alipay_transaction.total_amount,
refund_reason='Customer asked')
if refund_result['code'] == '10000':
refund_status = 0
payment_status = 5
else:
refund_status = 1
payment_status = 6
try:
logger_info.info(refund_result)
refund_result['order_id'] = order_id
refund_result['status'] = refund_status
refund_result['alipay_refund_validation'] = True
serializer = AlipayRefundSerializer(data=refund_result)
if serializer.is_valid():
serializer.save()
else:
logger_info.info(serializer.errors)
payment.payment_status = payment_status
payment.save()
except Exception as e:
logger_info.error(str(e))
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4002_PAYMENT_IS_NOT_FOUND))
result.set_error(code.ERROR_4002_PAYMENT_IS_NOT_FOUND)
return Response(result.get_response(), result.get_code())
elif payment_type == 1 or payment_type == 3:
if payment_type == 1:
wechat_app_id = 'viastelle'
merchant_id = 'viastelle'
else:
wechat_app_id = 'viastelle'
merchant_id = 'viastelle'
transaction = WechatQueryTransaction.objects.get(order_id=order_id)
total_fee = transaction.total_fee
refund_data = {
'appid': wechat_app_id,
'mch_id': merchant_id,
'nonce_str':
payment_util.wechat_payment_str(transaction.order_id),
'transaction_id': transaction.transaction_id,
'out_trade_no': order_id,
'out_refund_no': transaction.transaction_id,
'total_fee': total_fee,
'refund_fee': total_fee
}
if payment_type == 1:
refund_data_xml = payment_util.get_payment_wechat_dict_to_xml(
refund_data)
else:
refund_data_xml = payment_util.get_payment_wechat_public_dict_to_xml(
refund_data)
logger_info.info(refund_data_xml)
# refund_data_signed = utils.calculate_signature(prepaid_object, api_key)
# prepaid_data = utils.dict_to_xml(prepaid_object, prepaid_signature)
api_cert_dir = '/home/nexttf/workspace/project_aries/config/keys'
if payment_type == 1:
api_cert = 'app_pay_apiclient_cert.pem'
api_key = 'app_pay_apiclient_key.pem'
else:
api_cert = 'public_pay_apiclient_cert.pem'
api_key = 'public_pay_apiclient_key.pem'
api_cert_file = os.path.join(api_cert_dir, api_cert)
api_key_file = os.path.join(api_cert_dir, api_key)
"""
verify=True, cert=(self.cert_file, self.key_file))
"""
headers = {'Content-Type': 'application/xml'}
response = requests.post(url=get_wechat_refund_url(),
headers=headers,
data=refund_data_xml,
verify=True,
cert=(api_cert_file, api_key_file))
logger_info.info(response.text)
try:
refund_result = xmltodict.parse(response.text)['xml']
logger_info.info(refund_result)
if refund_result['return_code'] == 'SUCCESS':
refund_status = 0
payment_status = 5
else:
refund_status = 1
payment_status = 6
validation = payment_util.get_payment_wechat_sign_validation(
refund_result)
refund_result['status'] = refund_status
refund_result['order_id'] = order_id
refund_result['wechat_refund_validation'] = validation
serializer = WechatRefundSerializer(data=refund_result)
if serializer.is_valid():
serializer.save()
else:
logger_info.info(serializer.errors)
payment.payment_status = payment_status
payment.save()
if refund_status == 1:
logger_error.error(code.ERROR_4003_PAYMENT_REFUND_FAIL)
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4003_PAYMENT_REFUND_FAIL))
result.set_error(code.ERROR_4003_PAYMENT_REFUND_FAIL)
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4002_PAYMENT_IS_NOT_FOUND))
result.set_error(code.ERROR_4002_PAYMENT_IS_NOT_FOUND)
return Response(result.get_response(), result.get_code())
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
try:
trade_type = request_data['trade_type']
product_list = request_data['product_list']
validate_str = request_data['validate_str']
if validate_str != 'GoDbAcKeNdS':
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
get_msg(code.ARIES_401_UNAUTHORIZED))
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
get_msg(code.ARIES_401_UNAUTHORIZED))
return Response(result.get_response(), result.get_code())
try:
sales_status = 1
for product_item in product_list:
product_id = product_item['product_id']
quantity = product_item['quantity']
product = Product.objects.get(id=product_id)
menu = product.menu
hub = product.hub
product_stock = HubStock.objects.get(hub=hub, menu=menu)
stock_count = product_stock.stock
sold_count = product_stock.sold
if trade_type == 0:
stock_count -= quantity
sold_count += quantity
else:
stock_count += quantity
sold_count -= quantity
if sold_count <= 0:
sold_count = 0
if stock_count <= 0:
stock_count = 0
products = Product.objects.filter(hub=hub,
menu=menu,
status__lte=sales_status)
for sold_product in products:
sold_product_instance = Product.objects.get(
id=sold_product.id)
sold_product_instance.status = 0
sold_product_instance.save()
if stock_count >= 1:
product_status = product.status
if product_status == 0:
product.status = sales_status
product.save()
product_stock.stock = stock_count
product_stock.sold = sold_count
product_stock.save()
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
'Error : ' + str(e))
return Response(result.get_response(), result.get_code())
