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
