def post(self, request, time_bomb_id):
auth_info = header_parser.parse_auth_info(request)
request_data = request.data
try:
get_admin_token_validate_v2(auth_info.access_token)
# Request data validation
time_bomb_activation_validation(request_data)
# Get activate value
activate = request_data['activate']
time_bomb_manager = TimeBombManager(self.logger_info, self.logger_error)
activate_result = time_bomb_manager.set_time_bomb_activate_with_id(time_bomb_id, activate)
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:
self.logger_error.error(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e), None)
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('result', activate_result)
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)
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())
try:
order_manager = OrderManager(logger_info, logger_error)
order_list = order_manager.get_search_orders(request, False)
result.set('result', {
'orders': order_list,
'total_count': len(order_list)
})
result.set('orders', order_list)
result.set('total_count', len(order_list))
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 delete(self, request, page_id):
auth_info = header_parser.parse_auth_info(request)
curation_manager = CurationAdminManager(self.logger_info,
self.logger_error)
self.logger_info.info('[CurationPageAdmin][delete][' +
str(auth_info.open_id) +
str(auth_info.access_token) + ']')
try:
# Admin token validate
get_admin_token_validate_v2(auth_info.access_token)
curation_util.get_article_validation(page_id)
curation_manager.delete_curation_page(page_id)
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 = ResultResponse(code.ARIES_200_SUCCESS, 'success')
return Response(result.get_response(), result.get_code())
def get(self, request):
auth_info = header_parser.parse_auth_info(request)
self.logger_info.info('[CurationPageAdmin][get][' +
str(auth_info.open_id) +
str(auth_info.access_token) + ']')
status = int(request.GET.get('status', self.VISIBLE))
curation_manager = CurationAdminManager(self.logger_info,
self.logger_error)
try:
# Admin token validate
get_admin_token_validate_v2(auth_info.access_token)
page_list = curation_manager.read_curation_page_list(
status, self.LAYOUT_TYPE)
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 = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('curation_pages', page_list)
return Response(result.get_response(), result.get_code())
def post(self, request, hub_id):
auth_info = header_parser.parse_auth_info(request)
request_data = request.data
try:
# Request data validation
create_time_bomb_validation(request_data)
time_bomb = request_data['time_bomb']
tb_content_en = time_bomb['time_bomb_content_en']
tb_content_cn = time_bomb['time_bomb_content_cn']
del time_bomb['time_bomb_content_en']
del time_bomb['time_bomb_content_cn']
if 'time_bomb_discount_info' in time_bomb:
discount_info = time_bomb['time_bomb_discount_info']
del time_bomb['time_bomb_discount_info']
else:
discount_info = []
# Admin token check
get_admin_token_validate_v2(auth_info.access_token)
# Product available check
product_manager = ProductManagerV3(self.logger_info, self.logger_error)
product_manager.get_product_validation(discount_info)
# Get target hub instance
hub_manager = HubManagerV2(self.logger_info, self.logger_error)
time_bomb['hub'] = hub_manager.get_hub_instance(int(time_bomb['hub']))
# Create time bomb
time_bomb_manager = TimeBombManager(self.logger_info, self.logger_error)
time_bomb_manager.create_time_bomb(time_bomb, tb_content_en, tb_content_cn, discount_info)
# Get time bomb list
time_bomb_list = time_bomb_manager.get_time_bomb_list(hub_id)
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:
self.logger_error.error(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e), None)
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('time_bomb_list', time_bomb_list)
return Response(result.get_response(), result.get_code())
def get(self, request, order_id):
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())
try:
order_manager = OrderManager(logger_info, logger_error)
order_data = order_manager.get_order_detail(order_id)
open_id = order_data['open_id']
address_id = order_data['address_id']
# Get user information
user_data = api_request_util.get_user_info(open_id, access_token,
address_id)
if len(user_data['user_address']) >= 5:
order_data['user_address'] = user_data['user_address']
else:
order_data['user_address'] = get_user_address_data(
order_data['delivery_recipient_name'],
order_data['delivery_address_lat'],
order_data['delivery_address_lng'],
order_data['delivery_address'])
order_data['user'] = user_data['user']
order_data['user_info'] = user_data['user_info']
# Dada service
dada_service = DadaService(logger_info, logger_error)
order_data[
'shipping_order_detail'] = dada_service.read_dada_order_detail(
order_id)
result.set('order', order_data)
result.set('result', order_data)
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
return Response(result.get_response(), result.get_code())
def post(self, request):
auth_info = header_parser.parse_auth_info(request)
request_data = request.data
curation_manager = CurationAdminManager(self.logger_info,
self.logger_error)
self.logger_info.info('[CurationArticleAdmin][post][' +
str(auth_info.open_id) +
str(auth_info.access_token) + ']')
self.logger_info.info('[CurationArticleAdmin][post][' +
str(request_data) + ']')
try:
# Admin token validate
get_admin_token_validate_v2(auth_info.access_token)
# Data validation
curation_util.article_post_validation(request_data)
article = request_data['article']
content_en = article['content_en']
content_cn = article['content_cn']
del article['content_en']
del article['content_cn']
# Create curation article
curation_article = curation_manager.create_curation_article(
article, content_en, content_cn)
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 = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set_map(curation_article)
return Response(result.get_response(), result.get_code())
def put(self, request):
auth_info = header_parser.parse_auth_info(request)
request_data = request.data
curation_manager = CurationAdminManager(self.logger_info,
self.logger_error)
self.logger_info.info('[CurationPageAdmin][put][' +
str(auth_info.open_id) +
str(auth_info.access_token) + ']')
self.logger_info.info('[CurationPageAdmin][put][' + str(request_data) +
']')
try:
curation_util.page_post_validation(request_data)
# Admin token validate
get_admin_token_validate_v2(auth_info.access_token)
# Page data separation
curation_page = request_data['curation_page']
content_en = curation_page['content_en']
content_cn = curation_page['content_cn']
del curation_page['content_en']
del curation_page['content_cn']
curation_page = curation_manager.update_curation_page(
curation_page, content_en, content_cn)
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 = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('curation_page', curation_page)
return Response(result.get_response(), result.get_code())
def get(self, request, order_id):
# 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)
logger_info.info(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())
# Get order object
try:
order = Order.objects.get(order_id=order_id)
serializer = OrderSerializer(order)
order_data = serializer.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
del order_data['purchase_order']
result.set('result', order_data)
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Token or user not found')
return Response(result.get_response(), result.get_code())
def put(self, request):
auth_info = header_parser.parse_auth_info(request)
request_data = request.data
curation_manager = CurationAdminManager(self.logger_info,
self.logger_error)
self.logger_info.info('[CurationPageListAdmin][put][' +
str(auth_info.open_id) +
str(auth_info.access_token) + ']')
self.logger_info.info('[CurationPageListAdmin][put][' +
str(request_data) + ']')
try:
# Request validation
curation_util.page_list_update_post_validation(request_data)
# Admin token validate
get_admin_token_validate_v2(auth_info.access_token)
curation_pages = request_data['curation_pages']
curation_manager.update_curation_page_list(curation_pages)
page_list = curation_manager.read_curation_page_list(
self.STATUS_VISIBLE, self.LAYOUT_DEFAULT)
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 = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('curation_pages', page_list)
return Response(result.get_response(), result.get_code())
def get(self, request, hub_id):
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)
delivery_date = request.GET.get('delivery_date', None)
start_date = request.GET.get('start_date', None)
end_date = request.GET.get('end_date', None)
delivery_year = request.GET.get('delivery_year', None)
delivery_month = request.GET.get('delivery_month', None)
delivery_schedule = request.GET.get('delivery_schedule', None)
page = int(request.GET.get('page', 1))
limit = int(request.GET.get('limit', 100))
date_information = (start_date, end_date, delivery_date,
delivery_year, delivery_month)
order_manager = OrderManager(logger_info, logger_error)
order_list_result = order_manager.get_operation_orders(
hub_id, date_information, delivery_schedule, page, limit)
payload = order_manager.get_order_separation(order_list_result[0])
result.set('result', payload)
result.set('orders', payload['orders'])
result.set('total_count', order_list_result[1])
except AuthInfoError:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Authentication error')
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())
def get(self, request):
auth_info = header_parser.parse_auth_info(request)
self.logger_info.info('[CurationArticleAdmin][get][' +
str(auth_info.open_id) +
str(auth_info.access_token) + ']')
page = int(request.GET.get('page', self.ARTICLE_PAGE))
limit = int(request.GET.get('limit', self.DEFAULT_LIMIT))
layout_type = int(request.GET.get('layout_type', self.DEFAULT_LAYOUT))
curation_manager = CurationAdminManager(self.logger_info,
self.logger_error)
try:
# Admin token validate
get_admin_token_validate_v2(auth_info.access_token)
# Get article list
article_result = curation_manager.read_curation_article_list(
page, limit, layout_type)
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 = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('articles', article_result.article_list)
result.set('total_count', article_result.article_count)
return Response(result.get_response(), result.get_code())
def delete(self, request, time_bomb_id):
auth_info = header_parser.parse_auth_info(request)
try:
get_admin_token_validate_v2(auth_info.access_token)
time_bomb_manager = TimeBombManager(self.logger_info, self.logger_error)
time_bomb_manager.delete_time_bomb(time_bomb_id)
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:
self.logger_error.error(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e), None)
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
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 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 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())