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 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 get(self, request, product_id):
result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS_MSG)
lang_info = parse_language_v2(request.META)
target_db = lang_info.target_db
os_type = lang_info.os_type
cn_header = lang_info.cn_header
product_manager = ProductManagerV3(logger_info, logger_error)
menu_manager = MenuManagerV2(logger_info, logger_error)
# Get product data
product = product_manager.get_product_data(product_id)
menu_manager.get_menu_data(product, target_db, cn_header)
hub_id = product['hub']
# Check the current available time bomb
time_bomb_manager = TimeBombManager(logger_info, logger_error)
time_bomb_id = time_bomb_manager.get_time_bomb_now(hub_id, os_type)
if time_bomb_id is not None:
discount_map = product_manager.get_all_discount_info(time_bomb_id, cn_header)
# Time bomb information parsing
if product['id'] in discount_map:
discount_info = discount_map[product['id']]
add_discount_information(product, discount_info)
result.set('product', product)
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):
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):
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 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 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):
request_data = request.data
logger_info.info(request_data)
lang_info = parse_language_v2(request.META)
try:
login_type = request_data['login_type']
sign_in_manager = SignInManager(logger_info, logger_error)
sign_in_manager.set_login_info(login_type, request_data,
lang_info.accept_lang)
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data is invalid')
return Response(result.get_response(), result.get_code())
if sign_in_manager.login_validation():
result = sign_in_manager.do_sign_in()
sign_in_manager.update_user_information(request_data)
else:
logger_info.info('ID or password is incorrect')
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'ID or password is incorrect.')
return Response(result.get_response(), result.get_code())
def get(self, request, hub_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
auth_info = header_parser.parse_authentication(request)
lang_info = header_parser.parse_language_v2(request.META)
promotion_manager = PromotionManager(logger_info, logger_error,
lang_info.target_db)
promotion_manager.update_notification_count(auth_info)
page = int(request.GET.get('page', 1))
limit = int(request.GET.get('limit', 10))
os_type = int(request.GET.get('os_type', 2))
try:
# Get promotion list
promotion_list_result = promotion_manager.get_promotion_list(
page, limit, hub_id, os_type)
promotion_count = promotion_list_result[0]
promotion_list = promotion_list_result[1]
result.set('total_count', promotion_count)
result.set('promotions', promotion_list)
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data error')
return Response(result.get_response(), result.get_code())
return Response(result.get_response(), result.get_code())
def get(self, request, 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 post(self, request, hub_id, time):
result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS)
logger_info.info(str(time))
lang_info = header_parser.parse_language_v2(request.META)
cn_header = lang_info.cn_header
target_db = lang_info.target_db
os_type = lang_info.os_type
try:
product_list = request.data['product_list']
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid')
return Response(result.get_response(), result.get_code())
product_manager = ProductManagerV3(logger_info, logger_error)
menu_manager = MenuManager(logger_info, logger_error)
restaurant_manager = RestaurantManager(logger_info, logger_error)
hub_manager = HubManagerV2(logger_info, logger_error)
product_list = hub_manager.get_product_list(product_list, hub_id)
stock_list = hub_manager.get_stock_list(hub_id, product_list,
target_db, os_type)
for product in stock_list:
# Get product data
product_data = product_manager.get_product_for_valid(
product['product_id'], cn_header)
# Set time bomb information
if 'time_bomb_info' in product:
product['time_bomb_info']['stock'] = product['stock']
product['time_bomb_info']['has_stock'] = True
product_data['price_discount'] = product['price_discount']
product_data['event_product'] = product['event_product']
product_data['price_discount_event'] = True
product['product'] = product_data
# Get menu data
menu_id = product_data['menu']
menu_data = menu_manager.get_menu_data(target_db, menu_id,
product_data['sales_time'],
cn_header)
menu_data['review_statics'] = menu_manager.get_menu_statics(
menu_id)
menu_data['restaurant'] = restaurant_manager.get_restaurant_data(
menu_data['restaurant'], target_db)
product['product']['menu'] = menu_data
result.set('product_list', stock_list)
return Response(result.get_response(), result.get_code())
def get(self, request, product_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
lang_info = parse_language_v2(request.META)
target_db = lang_info.target_db
os_type = lang_info.os_type
cn_header = lang_info.cn_header
product_queryset = Product.objects.filter(id=product_id, type__lte=10)
product_count = product_queryset.count()
if product_count < 1:
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Product not found')
return Response(result.get_response(), status=result.get_code())
# Create manager
product_manager = ProductManagerV3(logger_info, logger_error)
menu_manager = MenuManagerV2(logger_info, logger_error)
review_manager = ReviewManager(logger_info, logger_error)
# Get product information
product = product_manager.get_product_data(product_id)
hub_id = product['hub']
# Parsing menu and restaurant data
menu_manager.get_menu_data(product, target_db, cn_header)
result.set('product', product)
# Recommend product information
product_list = product_manager.get_recommend_product(hub_id)
for product_obj in product_list:
menu_manager.get_menu_data(product_obj, target_db, cn_header)
result.set('products', product_list)
# Time bomb information
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_map = product_manager.get_all_discount_info(time_bomb_id, cn_header)
if product['id'] in discount_map:
discount_info = discount_map[product['id']]
add_discount_information(product, discount_info)
# Expert review
expert_review = review_manager.get_expert_review(target_db, product['menu']['id'])
result.set('expert_review', expert_review)
# Review articles
# reviews = review_manager.get_product_review(language_info[2], product_id)
result.set('total_count', 0)
result.set('page_size', 0)
result.set('customer_reviews', [])
return Response(result.get_response(), status=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)
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 get(self, request, promotion_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
lang_info = header_parser.parse_language_v2(request.META)
promotion_manager = PromotionManager(logger_info, logger_error,
lang_info.target_db)
try:
promotion_data = promotion_manager.get_promotion(promotion_id)
result.set('promotion', promotion_data)
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data error')
return Response(result.get_response(), result.get_code())
return Response(result.get_response(), result.get_code())
def get(self, request, 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 get(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
lang_info = header_parser.parse_language_v2(request.META)
accept_lang = lang_info.accept_lang
os_type = lang_info.os_type
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1]
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authorization error')
return Response(result.get_response(), result.get_code())
try:
# Get upcoming order list
order_manager = OrderManager(logger_info, logger_error)
order_list = order_manager.get_orders(order_manager.UPCOMING_ORDER, {
'open_id': open_id,
'order_status__lt': 3
})
result.set('upcoming_orders', order_list)
# Get user default hub id
user_information = api_request_util.get_user_information(open_id, access_token)
hub_id = user_information[1]['user']['default_hub_id'] if user_information[0] else 1
# Recommend product list
product_list = api_request_util.get_recommend_products(accept_lang, hub_id, os_type)
result.set('products', product_list)
# Check upcoming order notification
api_request_util.read_upcoming_order(open_id, access_token)
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e))
return Response(result.get_response(), result.get_code())
return Response(result.get_response(), result.get_code())
def get(self, request, hub_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
lang_info = header_parser.parse_language_v2(request.META)
target_db = lang_info.target_db
cn_header = lang_info.cn_header
os_type = lang_info.os_type
product_manager = ProductManagerV3(self.logger_info, self.logger_error)
product_list = product_manager.get_recommend_product(hub_id)
menu_manager = MenuManagerV2(self.logger_info, self.logger_error)
for product in product_list:
menu_manager.get_menu_data(product, target_db, cn_header)
# Check the current available time bomb
time_bomb_manager = TimeBombManager(self.logger_info,
self.logger_error)
time_bomb_id = time_bomb_manager.get_time_bomb_now(hub_id,
os_type,
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:
# Time bomb information parsing
if product['id'] in discount_map:
discount_info = discount_map[product['id']]
add_discount_information(product, discount_info)
result.set('hub_id', hub_id)
result.set('products', product_list)
return Response(result.get_response(), status=result.get_code())
def get(self, request):
self.logger_info.info('[HubDelivery][get]')
default_hub = 1
lang_info = parse_language_v2(request.META)
try:
hub_manager = HubManagerV2(logger_info, logger_error)
delivery_hub_list = hub_manager.get_hub_delivery(
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, 'success')
result.set('delivery_hub_list', delivery_hub_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, restaurant_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
language_info = header_parser.parse_language_v2(request.META)
date_info = product_util.get_date_information(1, self.LUNCH_TIME)
target_db = language_info[1]
try:
restaurant_manager = RestaurantManager(self.logger_info,
self.logger_error)
brand_data = restaurant_manager.get_brand(target_db, restaurant_id)
brand_id = brand_data['id']
result.set('brand', brand_data)
try:
brand_time = product_util.get_sales_time()
product_manager = ProductManager(self.logger_info,
self.logger_error,
language_info, date_info)
product_list = product_manager.get_brand_product_list(
self.PRODUCT_BRAND, brand_id, brand_time)
except Exception as e:
print(str(e))
result.set('products', [])
else:
result.set('products', product_list)
except ObjectDoesNotExist:
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Brand info not found.')
except Exception as e:
self.logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Error : ' + str(e))
return Response(result.get_response(), result.get_code())
def get(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
lang_info = header_parser.parse_language_v2(request.META)
accept_lang = lang_info.accept_lang
os_type = lang_info.os_type
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1]
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authorization error')
return Response(result.get_response(), result.get_code())
try:
# Get past order list
order_manager = OrderManager(logger_info, logger_error)
order_list = order_manager.get_orders(order_manager.PAST_ORDER, {
'open_id': open_id,
'order_status__gt': 9
})
result.set('past_orders', order_list)
# Get user default hub id
user_information = api_request_util.get_user_information(open_id, access_token)
hub_id = user_information[1]['user']['default_hub_id'] if user_information[0] else 1
# Recommend product list
product_list = api_request_util.get_recommend_products(accept_lang, hub_id, os_type)
result.set('products', product_list)
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid')
return Response(result.get_response(), result.get_code())
return Response(result.get_response(), result.get_code())
def 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):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
lang_info = parse_language_v2(request.META)
logger_info.info(request_data)
try:
login_type = request_data['login_type']
login_key = request_data['login_key']
login_value = request_data['login_value']
login_sns_open_id = ''
login_sns_access_token = ''
login_sns_refresh_token = ''
login_type = int(login_type)
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid')
return Response(result.get_response(), result.get_code())
# Mobile app/web: 0, QQ: 1, WeChat: 2, Password registration: 3
# Check sms verification & user count
if login_type == 0:
user_count = User.objects.filter(mdn=login_key).count()
# MDN is only one in member pool
if user_count >= 1:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_1005_USER_ALREADY_REGISTRATION))
result.set_error(code.ERROR_1005_USER_ALREADY_REGISTRATION)
logger_error.error(
get_msg(code.ERROR_1005_USER_ALREADY_REGISTRATION))
return Response(result.get_response(), result.get_code())
today = datetime.datetime.today()
sms_auth = SmsAuthHistory.objects.filter(
date=today, target_mdn=login_key).latest('id')
sms_auth_count = sms_auth.verification_count
if not sms_auth.has_verified or sms_auth_count > 3:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND))
result.set_error(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND)
logger_error.error(
get_msg(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND))
return Response(result.get_response(), result.get_code())
response = requests.get(
urlmapper.get_url('USER_SMS_VERIFICATION') + login_key)
if response.status_code != code.ARIES_200_SUCCESS:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND))
result.set_error(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND)
logger_error.error(
get_msg(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND))
return Response(result.get_response(), result.get_code())
# create open id
random_token = str(uuid.uuid4()).split('-')
open_id = str(random_token[0] + random_token[2] +
random_token[4]).upper()
# get token from server
if login_type is 0:
payload = {'user_open_id': open_id, 'user_account': login_key}
else:
payload = {
'user_open_id': open_id,
'user_account': login_sns_open_id
}
response = requests.post(urlmapper.get_url('PLATFORM_SERVER'),
json=payload)
if response.status_code == code.ARIES_200_SUCCESS:
response_json = response.json()
token = response_json['token']
token = str(token).upper()
else:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
'API connection fail')
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
logger_error.error(response.text)
return Response(result.get_response(), result.get_code())
# Sign-up user
if login_type is 0:
user_instance = User.objects.create(open_id=open_id,
mdn=login_key,
name=login_key,
mdn_verification=True,
access_token=token,
parent_type=0)
else:
user_instance = User.objects.create(open_id=open_id,
mdn='',
name=open_id[:6],
mdn_verification=False,
access_token=token)
UserLoginInfo.objects.create(
user=user_instance,
login_type=login_type,
login_key=login_key,
login_value=login_value,
login_sns_open_id=login_sns_open_id,
login_sns_access_token=login_sns_access_token,
login_sns_refresh_token=login_sns_refresh_token)
UserInfo.objects.create(user=user_instance, number_of_logon=0)
user_notify_info = UserNotifyInfo.objects.create(
user=user_instance)
UserGrade.objects.create(user=user_instance,
type=0,
extra_meal_point=0,
upgrade_date=datetime.datetime.now())
ShoppingBag.objects.create(user=user_instance, )
user_serializer = UserAccountSerializer(user_instance)
user_data = user_serializer.data
# User notify data
notify_info = UserNotifyInfo.objects.get(user=user_instance)
notify_info_serializer = UserNotifyInfoSerializer(notify_info)
notify_info_data = notify_info_serializer.data
del notify_info_data['id']
del notify_info_data['user']
user_data['notification_info'] = notify_info_data
# User grade data
user_grade = UserGrade.objects.get(user=user_instance)
grade_serializer = UserGradeSerializer(user_grade)
user_data['grade'] = grade_serializer.data
user_data['connection_account'] = json.loads(
user_data['connection_account'])
result.set('auto_registration', False)
result.set('user', user_data)
# If there is Member promotion, call member coupon interface
member_promo_result = request_member_promotion(
open_id, 0, lang_info.accept_lang)
result.set_map(member_promo_result)
logger_info.info('[views_sign][SignUp][post][' +
str(member_promo_result) + ']')
if member_promo_result['has_member_promotion']:
user_notify_info.has_new_coupon = True
user_notify_info.coupon_count = 1
user_notify_info.save()
# If there is a registration with referrer, update referrer count
if 'referrer_id' in request_data:
logger_info.info('[views_sign][SignUp][post][' +
'REFERRER SIGNUP' + ']')
user_mdn = user_instance.mdn
user_referral_service = UserReferralService(
logger_info, logger_error)
# Check if its mdn was used for registration before
registration_check = user_referral_service.read_user_referral_info_check(
user_mdn)
if registration_check:
share_id = request_data['referrer_id']
referrer_open_id = request_share_id_validation(share_id)
# Save User referral history
logger_info.info('[views_sign][SignUp][post][' +
str(open_id) + ']')
logger_info.info('[views_sign][SignUp][post][' +
str(user_mdn) + ']')
logger_info.info('[views_sign][SignUp][post][' +
str(share_id) + ']')
logger_info.info('[views_sign][SignUp][post][' +
str(referrer_open_id) + ']')
ref = user_referral_service.create_user_referral_info(
open_id, user_mdn, share_id, referrer_open_id)
logger_info.info('[views_sign][SignUp][post][' + str(ref) +
']')
user_service = UserService(logger_info, logger_error)
referrer_user = user_service.get_user_instance(
referrer_open_id)
referrer_notify_info = user_service.get_user_notify_info(
referrer_user)
referrer_notify_info.has_referral_event = True
referrer_notify_info.save()
logger_info.info(
'[views_sign][SignUp][post][Notification information saved]'
)
# Send notification
user_manager_v2 = UserManagerV2(logger_info, logger_error)
user_manager_v2.send_sign_up_push(referrer_open_id, True)
logger_info.info(
'[views_sign][SignUp][post][Send push completed]')
else:
logger_info.info(
'[views_sign][SignUp][post][Referral already registration.]'
)
# Change user info
user_info = UserInfo.objects.get(user=user_instance)
user_info.number_of_logon = F('number_of_logon') + 1
user_info.date_account_last_modified = datetime.datetime.now()
if 'os_type' in request_data:
if request_data['os_type'] == 0 or request_data['os_type'] == 1:
user_info.os_type = request_data['os_type']
user_info.save()
return Response(result.get_response(), status=result.get_code())
else:
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Sign up method not supported')
logger_info.info('Sign up method not supported')
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
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, hub_id):
lang_info = parse_language_v2(request.META)
today = datetime.datetime.today()
try:
# Latest schedule
target_schedule = DeliverySchedule.objects.filter(
hub_id=int(hub_id)).latest('-id')
delivery_day = today
# After 9:00 pm, next day setting
if delivery_day.time() > target_schedule.delivery_end:
next_day = today + datetime.timedelta(days=1)
else:
next_day = today
time_slots = json.loads(target_schedule.delivery_time_table)
available_time = 0
matched_table = []
for target_slot in time_slots:
time = datetime.datetime.strptime(
next_day.strftime("%Y.%m.%d") + ' ' +
target_slot["starttime"], "%Y.%m.%d %I:%M %p")
if today > time:
available_time += 1
else:
table = {
'index': target_slot['index'],
'starttime': target_slot['starttime'],
'endtime': target_slot['endtime'],
'delivery_price': target_schedule.delivery_price
}
matched_table.append(table)
minimum_order_price = target_schedule.minimum_order_price
order_available = target_schedule.order_available
if lang_info.cn_header:
unavailable_msg = target_schedule.unavailable_msg_chn
else:
unavailable_msg = target_schedule.unavailable_msg_eng
if not order_available:
order_unavailable_msg = unavailable_msg
else:
order_unavailable_msg = ''
except Exception as e:
result = ResultResponse(code.ARIES_400_BAD_REQUEST, str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS_MSG)
result.set('working_day', next_day.strftime('%Y.%m.%d'))
result.set('timetable', matched_table)
result.set('order_available', order_available)
result.set('minimum_order_price', minimum_order_price)
result.set('order_unavailable_message', order_unavailable_msg)
return Response(result.get_response(), result.get_code())
def get(self, request, order_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1]
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid')
return Response(result.get_response(), result.get_code())
lang_info = header_parser.parse_language_v2(request.META)
accept_lang = lang_info.accept_lang
os_type = lang_info.os_type
# Check order_id length
if len(order_id) < 17:
logger_error.error(code.ERROR_9001_PARAMETER_VALIDATION_FAILED)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_9001_PARAMETER_VALIDATION_FAILED))
result.set_error(code.ERROR_9001_PARAMETER_VALIDATION_FAILED)
return Response(result.get_response(), result.get_code())
# Request data parsing
try:
order = Order.objects.get(open_id=open_id, order_id=order_id)
purchase_order = PurchaseOrder.objects.get(order_id=order.order_id)
purchase_order_serializer = UpcomingPurchaseOrderSerializer(purchase_order)
purchase_order_data = purchase_order_serializer.data
purchase_order_data['order_details'] = json.loads(purchase_order_data['order_details'])
purchase_order_data['shipping_detail'] = json.loads(purchase_order_data['shipping_detail'])
del purchase_order_data['product_list']
del purchase_order_data['coupon_list']
del purchase_order_data['order_hash']
if purchase_order_data['extra_telephone'] is None:
purchase_order_data['extra_telephone'] = ''
if purchase_order_data['special_instruction'] is None:
purchase_order_data['special_instruction'] = ''
order_serializer = UpcomingOrderSerializer(order)
order_data = order_serializer.data
order_data['purchase_order'] = purchase_order_data
start_date = order.order_start_date.strftime(resources.DATE_WITH_AM_PM)
order_data['order_start_date'] = dateformatter.get_yymmdd_time(start_date)
del order_data['order_status_history']
if order.order_status == 11:
order_cancel_date = order.order_cancel_date
if order_cancel_date is not None:
order_cancel_date = order.order_cancel_date.strftime(resources.DATE_WITH_AM_PM)
order_data['order_cancel_date'] = dateformatter.get_yymmdd_time(order_cancel_date)
else:
order_data['order_cancel_date'] = ''
else:
order_data['order_cancel_date'] = ''
result.add(order_data)
product_list = json.loads(purchase_order.product_list)
headers = {'accept-language': accept_lang}
json_data = {
'product_list': product_list,
'open_id': open_id,
'order_id': order_id,
'hub_id': purchase_order_data['hub_id']
}
response = requests.post(urlmapper.get_url('MENU_VALIDATE'), headers=headers, json=json_data)
response_json = response.json()
result.set('reviews', response_json['reviews'])
result.set('review_items', response_json['review_items'])
except Exception as e:
logger_info.info(str(e))
print(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid')
return Response(result.get_response(), result.get_code())
# Get user default hub id
user_information = api_request_util.get_user_information(open_id, access_token)
hub_id = user_information[1]['user']['default_hub_id'] if user_information[0] else 1
# Recommend product list
product_list = api_request_util.get_recommend_products(accept_lang, hub_id, os_type)
result.set('products', product_list)
return Response(result.get_response(), result.get_code())
def post(self, request, hub_id=1):
try:
request_data = request.data
request_validation(request_data)
menu_id_list = request_data['menu_id_list']
target_db = request_data['target_db']
cn_header = False if target_db == 'default' else True
sales_time_str = get_sales_time_str()
date_info = get_date_information_v2(hub_id, sales_time_str)
lang_info = parse_language_v2(request.META)
os_type = lang_info.os_type
product_manager = ProductManagerV3(self.logger_info,
self.logger_error)
product_data = product_manager.get_product_info(
hub_id, menu_id_list)
menu_manager = MenuManagerV2(self.logger_info, self.logger_error)
product_list = []
for product in product_data:
product_list.append(
menu_manager.get_menu_data(product, target_db, cn_header))
# Check the current available time bomb
time_bomb_manager = TimeBombManager(self.logger_info,
self.logger_error)
time_bomb_id = time_bomb_manager.get_time_bomb_now(hub_id, os_type)
# Get time bomb information
if time_bomb_id is not None:
discount_map = product_manager.get_all_discount_info(
time_bomb_id, cn_header)
for product in product_list:
if product['id'] in discount_map:
discount_info = discount_map[product['id']]
add_discount_information(product, discount_info)
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
except Exception as e:
self.logger_info.info(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS_MSG)
result.set('products', product_list)
result.set('hub_id', int(hub_id))
result.set('time_type', date_info.time_type)
result.set('phase_next_day', date_info.phase_next_day)
result.set('phase_date', date_info.current_date.isoformat())
result.set('order_available',
product_util.get_available_time(date_info.time_type))
return Response(result.get_response(), result.get_code())
def 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())
