def post(self, request):
request_data = request.data
logger_info.info('[views_referral_coupon][ReferralCoupon][post][' +
str(request_data) + ']')
try:
coupon_issue_validation(request_data)
open_id = request_data['open_id']
coupon_list = request_data['coupon_list']
coupon_code = request_data['coupon_code']
sender_id = request_data['sender_id']
coupon_manager = CouponManagerV3(logger_info, logger_error)
coupon_manager.create_coupon_with_coupon_list(
open_id, coupon_list, coupon_code, sender_id)
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
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)
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 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 get(self, request, hub_id):
lang_info = parse_language_v2(request.META)
date_info = get_date_information_v3(hub_id)
target_db = lang_info.target_db
cn_header = lang_info.cn_header
os_type = lang_info.os_type
time_type = date_info.time_type
try:
# Get product list from specific hub
product_manager = ProductManagerV3(self.logger_info,
self.logger_error)
product_list = product_manager.get_product_list(
hub_id, date_info.current_date)
menu_manager = MenuManagerV2(self.logger_info, self.logger_error)
for product in product_list:
menu_manager.get_menu_data_for_list(product, target_db,
cn_header,
product['sales_time'])
# 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,
has_after=False)
if time_bomb_id is not None:
# Discount information add
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 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('hub_id', hub_id)
result.set('current_time_type', time_type)
result.set('phase_next_day', date_info.phase_next_day)
result.set('phase_date', date_info.current_date.isoformat())
result.set('products', product_list)
return Response(result.get_response(), status=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 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 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 post(self, request):
language_info = header_parser.parse_language_v2(request.META)
request_data = request.data
logger_info.info('[views_coupon][CouponInformation][post][' +
str(request.data) + ']')
try:
coupon_manager = CouponManagerV3(logger_info, logger_error)
coupon_info_list = coupon_manager.read_coupon_information(
request_data, language_info.target_db)
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('coupon_info', coupon_info_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):
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):
request_data = request.data
self.logger_info.info('[ReferralFirstPurchase][post][' +
str(request_data) + ']')
referral_manager = ReferralManager(self.logger_info, self.logger_error)
try:
open_id_param_validation(request_data)
open_id = request_data['open_id']
referral_manager.do_first_purchase_up(open_id)
except AuthInfoError:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Authentication error')
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
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)
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 post(self, request):
request_data = request.data
try:
request_validation(request_data)
open_id = request_data['open_id']
referral_service = UserReferralService(self.logger_info,
self.logger_error)
referral_info = referral_service.read_user_referral_info(open_id)
if referral_info is None:
referral_result = get_referral_result(False, '', '')
else:
ref_open_id = referral_info['referrer_open_id']
ref_share_id = referral_info['referrer_share_id']
referral_result = get_referral_result(True, ref_open_id,
ref_share_id)
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(referral_result)
return Response(result.get_response(), result.get_code())
def get(self, request):
language_info = header_parser.parse_language_v2(request.META)
referral_manager = ReferralManager(self.logger_info, self.logger_error)
try:
referral_info = referral_manager.get_referral_information(
language_info.accept_lang)
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('friend_coupon_status',
referral_info['friend_coupon_status'])
result.set('first_coupon_status',
referral_info['first_coupon_status'])
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):
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 post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
self.logger_info.info(request_data)
dada_manager = DadaManager(self.logger_info, self.logger_error)
try:
# request data validation
dada_util.dada_order_add_after_query_validation(request_data)
# Make a new order
query_result = dada_manager.order_add_after_query(request_data)
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_map(query_result)
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 get(self, request, hub_id):
lang_info = parse_language_v2(request.META)
lang_type = 1 if lang_info.cn_header else 0
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_id = time_bomb_manager.get_time_bomb_now(hub_id, os_type)
if time_bomb_id is None:
time_bomb = {'status': 0}
else:
time_bomb = time_bomb_manager.get_time_bomb(
time_bomb_id, lang_type, os_type)
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)
return Response(result.get_response(), result.get_code())
def do_sign_in(self):
token_result = self.get_token()
if token_result[0]:
token = token_result[1]
else:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
'Token validation fail')
return result
self.user.access_token = token
self.user.save()
user_serializer = UserAccountSerializer(self.user)
user_data = user_serializer.data
user_grade = UserGrade.objects.get(user=self.user)
user_grade_serializer = UserGradeSerializer(user_grade)
user_data['grade'] = user_grade_serializer.data
user_data['connection_account'] = json.loads(
user_data['connection_account'])
# User notify data
notify_info = UserNotifyInfo.objects.get(user=self.user)
# User notify information update
user_news_count = UserNews.objects.filter(user=self.user,
has_read=False).count()
notify_info.news_count = user_news_count
self.update_notification_info(user_data['open_id'],
user_data['access_token'], notify_info)
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
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('user', user_data)
result.set('auto_registration', self.auto_registration)
# Member promotion coupon issue section
if self.auto_registration:
member_promo_result = request_member_promotion(
self.user.open_id, 0, self.accept_lang)
result.set_map(member_promo_result)
if member_promo_result['has_member_promotion']:
notify_info.has_new_coupon = True
notify_info.coupon_count = 1
notify_info.save()
return result
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):
lang_info = header_parser.parse_language_v2(request.META)
request_data = request.data
logger_info.info('[views_referral_coupon][PromotionCoupon][post][' +
str(request_data) + ']')
try:
member_coupon_issue_validation(request_data)
open_id = request_data['open_id']
promotion_type = request_data['promotion_type']
promotion_manager = PromotionManager(logger_info, logger_error,
lang_info)
lang_type = 1 if lang_info.cn_header else 0
member_promotion = promotion_manager.get_promotion_list_with_latest(
promotion_type, lang_type)
if member_promotion is None:
has_member_promotion = False
member_promotion = {}
else:
has_member_promotion = True
coupon_id = member_promotion['coupon_id']
coupon_days = member_promotion['coupon_days']
coupon_code = member_promotion['coupon_code']
sender_id = member_promotion['sender_id']
coupon_manager = CouponManagerV3(logger_info, logger_error)
coupon_manager.create_coupon_with_promotion(
open_id, coupon_id, coupon_days, coupon_code, sender_id)
member_promotion = member_promotion_filtering(member_promotion)
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
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('has_member_promotion', has_member_promotion)
result.set('member_promotion', member_promotion)
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):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
self.logger_info.info(request_data)
dada_manager = DadaManager(self.logger_info, self.logger_error)
try:
# request data validation
dada_util.dada_query_validation(request_data)
# Make a new order
query_result = dada_manager.order_location_query(request_data)
# Select result of query
selected_result = {
'orderId': query_result['orderId'],
'statusCode': query_result['statusCode'],
'transporterName': query_result['transporterName'],
'transporterPhone': query_result['transporterPhone'],
'transporterLng': query_result['transporterLng'],
'transporterLat': query_result['transporterLat'],
'createTime': query_result['createTime'],
'acceptTime': query_result['acceptTime'],
'fetchTime': query_result['fetchTime'],
'finishTime': query_result['finishTime'],
'cancelTime': query_result['cancelTime']
}
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_map(selected_result)
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 post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
self.logger_info.info(request_data)
dada_manager = DadaManager(self.logger_info, self.logger_error)
try:
# request data validation
dada_util.dada_new_order_validation(request_data)
order_id = request_data['order_id']
receiver_address = request_data['receiver_address']
receiver_lat = request_data['receiver_lat']
receiver_lng = request_data['receiver_lng']
# Make a new order
dada_manager.add_order(request_data)
# Make a new order detail
dada_manager.add_order_detail(order_id, receiver_address,
receiver_lat, receiver_lng)
# Read dada order 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, hub_id):
self.logger_info.info('[AdminProductV2][get][' + hub_id + ']')
lang_info = parse_language_v2(request.META)
target_db = lang_info.target_db
cn_header = lang_info.cn_header
today_str = str(datetime.datetime.today())[:10]
start_date = str(request.GET.get('start_date', today_str))
end_date = str(request.GET.get('end_date', today_str))
try:
product_manager = ProductManagerV3(self.logger_info, self.logger_error)
product_list = product_manager.get_product_list_with_query(hub_id, start_date, end_date)
menu_manager = MenuManagerV2(self.logger_info, self.logger_error)
for product in product_list:
menu_manager.get_menu_data(product, target_db, cn_header)
menu_data = product['menu']
product['menu'] = {
'image_main': menu_data['image_main'],
'name': menu_data['name'],
'restaurant_name': menu_data['restaurant']['name']
}
product_data = product_manager.get_product_data(product['id'])
product['badge_en'] = json.loads(product_data['badge_en'])
product['badge_cn'] = json.loads(product_data['badge_cn'])
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message, err_code)
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('product_list', product_list)
result.set('hub_id', int(hub_id))
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)
dada_manager = DadaManager(self.logger_info, self.logger_error)
try:
# request data validation
dada_util.dada_order_add_tip_validation(request_data)
order_id = request_data['order_id']
tips = request_data['tips']
city_code = request_data['city_code']
info = request_data['info']
# add order tips
dada_manager.add_tip(order_id, tips, city_code, info)
# Read dada detail
dada_order_data = dada_manager.update_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 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())
