def get(self, request):
auth_info = header_parser.parse_auth_info(request)
lang_info = parse_language_v2(request.META)
if auth_info.open_id is not None:
logger_info.info('[HubGeoInformation][get][' +
str(auth_info.open_id) + ']')
try:
hub_manager = HubManagerV2(logger_info, logger_error)
hub_list = hub_manager.get_hub_list(self.DEFAULT_HUB,
lang_info.cn_header,
lang_info.target_db)
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, self.SUCCESS_MSG)
result.set('hub_list', hub_list)
return Response(result.get_response(), result.get_code())
def put(self, request, hub_id):
self.logger_info.info('[UserAddressHubSelector][put][' + str(hub_id) + ']')
auth_info = header_parser.parse_auth_info(request)
lang_info = parse_language_v2(request.META)
try:
check_auth_info_v2(auth_info.open_id, auth_info.access_token)
address_manager = AddressManagerV2(self.logger_info, self.logger_error)
address_list = address_manager.select_hub(auth_info.open_id, lang_info.cn_header, int(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:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('user_addresses', address_list)
return Response(result.get_response(), result.get_code())
def put(self, request):
auth_info = header_parser.parse_auth_info(request)
open_id = auth_info.open_id
request_data = request.data
try:
# Cart request validation
cart_inst_validation(request_data)
include_cutlery = request_data['include_cutlery']
special_instruction = request_data['special_instruction']
user_manager = UserManagerV2(self.logger_info, self.logger_error)
# User information
cart_info = user_manager.get_user_cart_info_data(open_id)
user_manager.update_cart_info(cart_info, include_cutlery, special_instruction)
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')
return Response(result.get_response(), result.get_code())
def post(self, request):
request_data = request.data
self.logger_info.info('[UserReceiptList][post][' + str(request_data) +
']')
auth_info = header_parser.parse_auth_info(request)
lang_info = parse_language_v2(request.META)
try:
check_auth_info_v2(auth_info.open_id, auth_info.access_token)
receipt_util.request_validation(auth_info.open_id, request_data)
receipt_manager = ReceiptManager(self.logger_info,
self.logger_error)
receipt_list = receipt_manager.create_user_receipt(
auth_info.open_id, request_data, lang_info.cn_header)
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('user_receipts', receipt_list)
return Response(result.get_response(), result.get_code())
def put(self, request, address_id):
self.logger_info.info('[UserAddressSelector][put][' + str(address_id) + ']')
auth_info = header_parser.parse_auth_info(request)
try:
check_auth_info_v2(auth_info.open_id, auth_info.access_token)
# Get address data
address_manager = AddressManagerV2(self.logger_info, self.logger_error)
address_data = address_manager.get_address(auth_info.open_id, address_id)
# Check delivery area
address_select_validation(address_data['delivery_area'])
# Select address
address_list = address_manager.select_address(auth_info.open_id, int(address_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:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('user_addresses', address_list)
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, order_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
auth_info = header_parser.parse_auth_info(request)
self.logger_info.info(auth_info.access_token)
dada_manager = DadaManager(self.logger_info, self.logger_error)
try:
# Read dada detail
dada_order_data = dada_manager.read_order_detail(order_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:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result.set('shipping_order_detail', dada_order_data)
return Response(result.get_response(), result.get_code())
def get(self, request):
auth_info = header_parser.parse_auth_info(request)
lang_info = header_parser.parse_language_v2(request.META)
logger_info.info('[views_coupon][CouponDetail][get][' +
str(auth_info.open_id) + ']')
try:
coupon_manager = CouponManagerV3(logger_info, logger_error)
result_map = coupon_manager.get_coupon_detail(
auth_info.open_id, lang_info.target_db, auth_info.access_token)
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, self.SUCCESS_MSG)
result.set_map(result_map)
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, 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, address_id):
self.logger_info.info('[UserAddressDetail][get][' + str(address_id) + ']')
auth_info = header_parser.parse_auth_info(request)
try:
address_req_validation(auth_info.open_id, auth_info.access_token)
check_auth_info_v2(auth_info.open_id, auth_info.access_token)
# Read specific address
address_manager = AddressManagerV2(self.logger_info, self.logger_error)
user_address = address_manager.get_address(auth_info.open_id, int(address_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:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('user_address', user_address)
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 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 post(self, request):
auth_info = header_parser.parse_auth_info(request)
lang_info = header_parser.parse_language_v2(request.META)
request_data = request.data
self.logger_info.info('[ReferralCoupon][post][' +
str(auth_info.open_id) +
str(auth_info.access_token) + ']')
self.logger_info.info('[ReferralCoupon][post][' + str(request_data) +
']')
try:
referral_authentication_validation(auth_info)
coupon_issue_validation(request_data)
open_id = auth_info.open_id
coupon_list = request_data['coupon_list']
coupon_type = request_data['coupon_type']
referral_manager = ReferralManager(self.logger_info,
self.logger_error)
res_map = referral_manager.issue_referral_coupon(
open_id, lang_info.cn_header, coupon_type, coupon_list)
update_coupon_count_no_log(auth_info.open_id,
auth_info.access_token, 0,
len(coupon_list))
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(res_map)
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 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):
auth_info = header_parser.parse_auth_info(request)
language_info = header_parser.parse_language_v2(request.META)
logger_info.info('[views_coupon][CouponPage][get][' +
auth_info.open_id + ',' + auth_info.access_token +
']')
try:
coupon_manager = CouponManagerV3(logger_info, logger_error)
check_auth_info_v2(auth_info.open_id, auth_info.access_token)
page = int(request.GET.get('page', 1))
limit = int(request.GET.get('limit', 20))
coupon_data = coupon_manager.get_coupon_list(
auth_info.open_id, auth_info.access_token,
language_info.target_db, page, limit, self.EXPIRED_DAY)
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(coupon_data)
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 get(self, request):
auth_info = header_parser.parse_auth_info(request)
language_info = header_parser.parse_language_v2(request.META)
self.logger_info.info('[views_referral][ReferralBoard][get][' +
str(auth_info.open_id) +
str(auth_info.access_token) + ']')
referral_manager = ReferralManager(self.logger_info, self.logger_error)
try:
referral_authentication_validation(auth_info)
open_id = auth_info.open_id
access_token = auth_info.access_token
accept_lang = language_info.accept_lang
referral_event = referral_manager.get_referral_status(
open_id, access_token, accept_lang)
request_notify_info(open_id, access_token, False)
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('referral_event', referral_event)
return Response(result.get_response(), result.get_code())
def post(self, request):
request_data = request.data
self.logger_info.info('[UserAddressList][post][' + str(request_data) + ']')
auth_info = header_parser.parse_auth_info(request)
try:
address_req_validation(auth_info.open_id, auth_info.access_token)
check_auth_info_v2(auth_info.open_id, auth_info.access_token)
# Request data check
address_create_data_check(request_data)
# Create user address
address_manager = AddressManagerV2(self.logger_info, self.logger_error)
created_address = address_manager.create_address(auth_info.open_id, request_data)
# Read latest address list
address_list = address_manager.get_address_list(auth_info.open_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:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('user_addresses', address_list)
result.set('user_address_id', created_address['id'])
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 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 get(self, request):
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
try:
check_auth_info_v2(auth_info.open_id, auth_info.access_token)
user_manager = UserManagerV2(self.logger_info, self.logger_error)
# User information
user_data = user_manager.get_user_data(open_id)
user_info = user_manager.get_user_info(open_id)
# Default hub id
default_hub_id = user_data['default_hub_id']
# Latest payment method and shipping method
latest_payment_method = user_info['latest_payment_method']
latest_shipping_method = user_info['latest_shipping_method']
# Latest cart information and special instruction template
cart_info = user_manager.get_user_cart_info_data(open_id)
include_cutlery = cart_info['include_cutlery']
user_inst_template = cart_util.get_user_inst_list(cn_header, cart_info['instruction_history'])
special_instruction_template = cart_util.get_sp_inst_template(cn_header)
# Delivery time table information (map)
delivery_map = cart_util.get_delivery_time(default_hub_id, lang_info.accept_lang)
# Add order unavailable message
order_available = delivery_map['order_available']
order_un_msg = payment_util.get_order_unavailable_msg(cn_header) if not order_available else ''
# Purchase information (map)
purchase_map = cart_util.get_purchases_data(open_id, access_token, accept_lang)
# Next day information
phase_next_day = product_util.get_phase_next_day()
# Recommend product information
products = cart_util.get_recommend_product(default_hub_id, accept_lang)
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('latest_payment_method', latest_payment_method)
result.set('latest_shipping_method', latest_shipping_method)
result.set('special_instruction_template', special_instruction_template + user_inst_template)
result.set('order_unavailable_message', order_un_msg)
result.set('phase_next_day', phase_next_day)
result.set('products', products)
result.set('include_cutlery', include_cutlery)
result.set_map(delivery_map)
result.set_map(purchase_map)
return Response(result.get_response(), result.get_code())
