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())