def get_payment_params(self, payment_params): order_id = payment_params['order_id'] total_price = payment_params['total_price'] product_title = payment_params['product_title'] cn_header = payment_params['cn_header'] nonce_str = payment_util.wechat_payment_str(order_id) prepaid_data = payment_util.get_payment_wechat_app(False, order_id, total_price, product_title, nonce_str) self.logger_info.info(prepaid_data) headers = {'Content-Type': 'application/xml'} response = requests.post(url=get_wechat_prepaid_url(), data=prepaid_data, headers=headers) if response.status_code != code.ARIES_200_SUCCESS: self.logger_error.error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED) raise BusinessLogicError(message_mapper.get(4004, cn_header), 4004, None) response_data = response.text prepaid_result = xmltodict.parse(response_data)['xml'] self.logger_info.info(prepaid_result) if not self.check_prepaid_result(prepaid_result): self.logger_error.error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED) raise BusinessLogicError(message_mapper.get(4004, cn_header), 4004, None) prepaid_id = prepaid_result['prepay_id'] payment_order = payment_util.get_payment_order_app( False, self.wechat_app_id, self.merchant_id, prepaid_id, nonce_str, self.api_key ) self.logger_info.info(payment_order) param_result = {'wechat_pay_order': payment_order} return param_result
def get_payment_params(self, payment_params): ip_addr = payment_params['ip_addr'] wechat_code = payment_params['wechat_code'] cn_header = payment_params['cn_header'] order_id = payment_params['order_id'] total_price = payment_params['total_price'] product_title = payment_params['product_title'] # WeChat public account login payload = {'appid': 'wx41b86399fee7a2ec', 'secret': '1b3d5dce9860be7e4fc04847df6a6177', 'code': wechat_code, 'grant_type': 'authorization_code'} response = requests.get(resources.WECHAT_ACCESS_TOKEN_URL, params=payload) response_json = response.json() if response.status_code != code.ARIES_200_SUCCESS or not response_json.get('openid'): raise BusinessLogicError(message_mapper.get(4004, cn_header), 4004, None) wechat_openid = response_json['openid'] nonce_str = payment_util.wechat_payment_str(order_id) prepaid_data = payment_util.get_payment_wechat_public( order_id, total_price, product_title, nonce_str, ip_addr, wechat_openid ) self.logger_info.info(prepaid_data) headers = {'Content-Type': 'application/xml'} response = requests.post(url=get_wechat_prepaid_url(), data=prepaid_data, headers=headers) if response.status_code != code.ARIES_200_SUCCESS: raise BusinessLogicError(message_mapper.get(4004, cn_header), 4004, None) response_data = response.text.encode('utf-8') prepaid_result = xmltodict.parse(response_data)['xml'] self.logger_info.info(prepaid_result) if prepaid_result['return_code'] == 'FAIL' or prepaid_result['result_code'] != 'SUCCESS': raise BusinessLogicError(message_mapper.get(4004, cn_header), 4004, None) prepaid_id = prepaid_result['prepay_id'] mobile_web_payment_params = { 'appId': 'wx41b86399fee7a2ec', 'timeStamp': str(dateformatter.get_timestamp()), 'nonceStr': nonce_str, 'package': 'prepay_id=' + prepaid_id, 'signType': 'MD5' } sign = payment_util.get_payment_wechat_public_signing(mobile_web_payment_params, nonce_str) mobile_web_payment_params['paySign'] = sign param_result = {'mobile_web_payment_params': mobile_web_payment_params} return param_result
def product_validation(self, validation_result): has_changed = validation_result['has_changed'] response_list = validation_result['product_list'] valid_list = list() invalid_list = list() if has_changed: original_product_count = len(self.product_list_json) response_product_count = len(response_list) if original_product_count != response_product_count: error_message = message_mapper.get(3001, self.cn_header) data_set = {'product_list': response_list, 'has_changed': has_changed} raise BusinessLogicError(error_message, 3001, data_set) for product in self.product_list_json: for response_product in response_list: if product['product_id'] == response_product['prev_product_id']: if product['quantity'] <= response_product['stock']: valid_list.append({ 'product_id': response_product['product_id'], 'quantity': product['quantity'] }) else: invalid_list.append({ 'product_id': response_product['product_id'], 'quantity': response_product['stock'], }) elif product['product_id'] == response_product['product_id']: if product['quantity'] <= response_product['stock']: valid_list.append({ 'product_id': response_product['product_id'], 'quantity': product['quantity'] }) else: invalid_list.append({ 'product_id': response_product['product_id'], 'quantity': response_product['stock'], }) if len(invalid_list) > 0: self.logger_error.error(code.ERROR_3001_PRODUCT_ALREADY_SOLD) error_message = message_mapper.get(3001, self.cn_header) data_set = {'product_list': response_list, 'has_changed': has_changed} raise BusinessLogicError(error_message, 3001, data_set) response_list = valid_list else: response_list = self.product_list_json return response_list
def draw_event_validation(event_list, cn_header): if len(event_list) <= 0: err_code = 5003 message = message_mapper.get(err_code, cn_header) raise BusinessLogicError(message, err_code) prob_sum = 0 for event in event_list: prob_sum += event['probability'] if prob_sum != 1: err_code = 5003 message = message_mapper.get(err_code, cn_header) raise BusinessLogicError(message, err_code)
def event_coupon_validator(request, cn_header=True): request_data = request.data if 'open_id' not in request_data or 'coupon_id' not in request_data: raise BusinessLogicError(message_mapper.get(1016, cn_header), 1016) return request_data
def check_issue_coupon_pack(self, auth_info, coupon_list, cn_header): coupon_service = CouponService(self.logger_info, self.logger_error) coupon_id_list = [coupon[0] for coupon in coupon_list] if coupon_service.read_customer_coupon_count(auth_info[0], coupon_id_list) != 0: raise BusinessLogicError(message_mapper.get(3105, cn_header), 3105)
def create_coupon_pack(self, auth_info, coupon_list, cn_header): coupon_service = CouponService(self.logger_info, self.logger_error) coupon_id_list = [coupon[0] for coupon in coupon_list] if coupon_service.read_customer_coupon_count(auth_info[0], coupon_id_list) != 0: raise BusinessLogicError(message_mapper.get(3105, cn_header), 3105) start_date = datetime.datetime.today() for coupon in coupon_list: coupon_id = coupon[0] period = coupon[1] coupon_code = coupon[2] sender_id = coupon[3] end_date = start_date + datetime.timedelta(days=period) if period >= 1: end_date = end_date - datetime.timedelta(days=1) coupon_service.create_customer_coupon(auth_info[0], coupon_id, coupon_code, start_date, end_date, sender_id) update_coupon_count(self.logger_info, self.logger_error, auth_info[0], auth_info[1], 0, len(coupon_list))
def set_delivery_detail(self, cn_header): # Shipping method self.request_data['shipping_method'] = 1 if 'delivery_on_site' in self.request_data: delivery_on_site = self.request_data['delivery_on_site'] else: delivery_on_site = False self.request_data['delivery_on_site'] = False if delivery_on_site: delivery_type = 2 self.request_data['shipping_method'] = 2 self.request_data['shipping_cost'] = 0.0 self.request_data['delivery_as_fast'] = False else: self.request_data['shipping_cost'] = 8.0 delivery_type = self.request_data['shipping_method'] # add shipping name delivery_name = hub_data.get_delivery_service_str(cn_header, delivery_type) self.request_data['shipping_name'] = delivery_name delivery_price = self.request_data['shipping_cost'] # Check delivery price if float(hub_data.get_shipping_cost(delivery_type)) != float(delivery_price): self.logger_info.info('Some cost is incorrect') raise DataValidationError('Some costs are incorrect') delivery_detail_json = {'delivery_title': hub_data.get_delivery_str(cn_header, delivery_type), 'price': delivery_price} self.order_details['delivery_detail'] = delivery_detail_json delivery_date = self.request_data['delivery_date'].replace('.', '-') self.request_data['delivery_date'] = delivery_date time_table_delivery_type = delivery_type if delivery_on_site: time_table_delivery_type = 1 time_table_address = '{}/{}/{}/{}/{}'.format( urlmapper.get_url('TIMETABLE_LIST'), str(self.request_data['hub_id']), delivery_date, str(self.request_data['delivery_schedule']), str(time_table_delivery_type) ) response = requests.get(time_table_address) response_json = response.json() if response.status_code != code.ARIES_200_SUCCESS: self.logger_error.error(code.ERROR_3007_DELIVERY_SCHEDULE_INVALID) raise BusinessLogicError(message_mapper.get(3007, cn_header), 3007, None) self.logger_info.info(response_json) self.request_data['shipping_detail'] = json.dumps(response_json['shipping_detail']) self.request_data['delivery_start_time'] = response_json['delivery_start_time'] self.request_data['delivery_end_time'] = response_json['delivery_end_time']
def check_play_condition(event, cn_header): event_available = event['event_available'] already_played = event['already_played'] result = True message = '' err_code = 0 if not event_available: message = message_mapper.get(5001, cn_header) err_code = 5001 result = False elif already_played: message = message_mapper.get(5002, cn_header) err_code = 5002 result = False if not result: raise BusinessLogicError(message, err_code) return
def create_user_receipt(self, user_open_id, user_receipt_data, cn_header): """ Create user receipt :param user_open_id: User open id :param user_receipt_data: User receipt data to create :param cn_header: Language data :return: Created user and user receipt list json object """ user_instance = self.user_service.get_user_instance(user_open_id) receipt_count = self.receipt_service.read_user_receipt_count( user_instance) if receipt_count >= 5: err_code = code.ERROR_1201_RECEIPT_LIMIT_ERROR err_msg = message_mapper.get(err_code, cn_header) raise BusinessLogicError(err_msg, err_code, None) receipt_data = self.receipt_service.create_user_receipt( user_instance, user_receipt_data) receipt_id = receipt_data['id'] self.receipt_service.select_receipt(user_instance, receipt_id) return self.receipt_service.read_user_receipt(user_instance, cn_header)
def sales_time_validation(self, product_list): headers = {'accept-language': self.accept_lang} payload = {'product_list': product_list, 'delivery_schedule': self.request_data['delivery_schedule']} response = requests.post(urlmapper.get_url('PRODUCT_VALIDATION'), headers=headers, json=payload) response_json = response.json() # If quantity of product to purchase quantity is not valid or delivery schedule invalid if response.status_code != code.ARIES_200_SUCCESS: self.logger_error.error(response_json['error_code']) raise BusinessLogicError(response_json['error_message'], None, None) # Sales time check if 'sales_time' not in self.request_data: self.request_data['sales_time'] = response_json['sales_time'] request_sales_time = self.request_data['sales_time'] now_sales_time = product_util.get_sales_time() if request_sales_time == 2 and now_sales_time == 3: self.logger_error.error(code.ERROR_3015_PRODUCT_DELIVERY_TIME_INVALID) data_set = {'product_list': response_json['product_list']} raise BusinessLogicError(message_mapper.get(3015, self.cn_header), 3015, data_set) return response_json
def issue_referral_coupon(self, open_id, cn_header, coupon_type, coupon_list): referral_event = self.referral_service.read_referral_event(open_id) if coupon_type == 0: target_coupon_list = referral_event['friend_coupon_status'] user_reward_count = referral_event['friend_membership_count'] else: target_coupon_list = referral_event['first_coupon_status'] user_reward_count = referral_event['first_purchase_rest_count'] # Find target coupons issue_coupon_list = [] coupon_reward_count = 0 for req_coupon in coupon_list: for tag_coupon in target_coupon_list: if tag_coupon['id'] == req_coupon['id']: # Coupon reward condition check coupon_reward_count = tag_coupon['reward_count'] coupon_issue_complete = tag_coupon['issue_complete'] if coupon_issue_complete: raise BusinessLogicError(message_mapper.get(3202, cn_header), 3202, None) if user_reward_count < coupon_reward_count: raise BusinessLogicError(message_mapper.get(3201, cn_header), 3201, None) issue_coupon_list.append(tag_coupon) # Coupon reward point update if coupon_type == 1: all_reward_count = len(coupon_list)*coupon_reward_count self.referral_service.update_referral_first_information(open_id, all_reward_count) # Coupon issue and User coupon_count update coupon_code = 'referral_20180725' sender_id = 'Admin' issue_coupon(open_id, cn_header, issue_coupon_list, coupon_code, sender_id) # Get new referral information referral_event = self.referral_service.read_referral_event(open_id) if coupon_type == 0: target_coupon_list = referral_event['friend_coupon_status'] user_reward_count = referral_event['friend_membership_count'] else: target_coupon_list = referral_event['first_coupon_status'] user_reward_count = referral_event['first_purchase_rest_count'] # Rest coupon status check has_reset = False if coupon_type == 0: for coupon in issue_coupon_list: for user_coupon in target_coupon_list: if coupon['id'] == user_coupon['id']: user_coupon['issue_available'] = False user_coupon['issue_complete'] = True else: if user_reward_count <= 0: for coupon in target_coupon_list: coupon['issue_available'] = False coupon['issue_complete'] = False else: for coupon in target_coupon_list: coupon['issue_available'] = True coupon['issue_complete'] = False self.referral_service.update_referral_coupon_status(open_id, coupon_type, target_coupon_list) # Get new referral information referral_event = self.referral_service.read_referral_event(open_id) if coupon_type == 0: target_coupon_list = referral_event['friend_coupon_status'] else: target_coupon_list = referral_event['first_coupon_status'] # Get coupon id and description, name accept_lang = 'zh' if cn_header else 'en' coupon_ids = [] for coupon in target_coupon_list: coupon['description'] = ref_util.get_coupon_description(30, accept_lang) coupon_ids.append(coupon['id']) coupon_info = get_coupon_information(coupon_ids, accept_lang) for coupon in coupon_info: coupon_id = coupon['id'] for target_coupon in target_coupon_list: if target_coupon['id'] == coupon_id: cash_discount = int(coupon['cash_discount']) if coupon_type == 0: target_coupon['name'] = ref_util.friend_coupon_naming(str(cash_discount), accept_lang) else: target_coupon['name'] = ref_util.pur_coupon_naming(str(cash_discount), accept_lang) # Result mapping from coupon_list if coupon_type == 0: friend_membership_count = referral_event['friend_membership_count'] # Friend membership count if friend_membership_count > 25: friend_membership_count = 25 referral_over = True else: referral_over = False if referral_event['friend_membership_over']: self.referral_service.update_referral_over_flag(open_id, False) result = { 'coupon_status': target_coupon_list, 'has_reset': has_reset, 'friend_membership_count': friend_membership_count, 'friend_membership_over': referral_over } else: rest_point = referral_event['first_purchase_rest_count'] result_coupon_list = [] if len(target_coupon_list) >= 1: coupon = target_coupon_list[0] for index in range(rest_point): result_coupon_list.append(coupon) result = { 'coupon_status': result_coupon_list, 'has_reset': has_reset } return result
def check_history_list(history_list, cn_header): if len(history_list) >= 1: err_code = 5002 message = message_mapper.get(err_code, cn_header) raise BusinessLogicError(message, err_code)
def os_info_validator(request, cn_header=True): os_type = int(request.GET.get('os_type', 2)) if os_type > 1: raise BusinessLogicError(message_mapper.get(3106, cn_header), 3106) return True
def auth_info_validator(auth_info, cn_header=True): if auth_info[0] is None or auth_info[1] is None: raise BusinessLogicError(message_mapper.get(1016, cn_header), 1016) return True