def get(self, request, open_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
# This open id is not open id
mdn = open_id
cn_header = False
# Popup header check
try:
accept_lang = request.META['HTTP_ACCEPT_LANGUAGE']
if 'zh' in accept_lang:
cn_header = True
except Exception as e:
print(e)
response = requests.get(
urlmapper.get_url('USER_SMS_VERIFICATION') + open_id)
if response.status_code != code.ARIES_200_SUCCESS:
logger_info.info(response.text)
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Verification info is not found')
return Response(result.get_response(), result.get_code())
try:
user_login_info_count = UserLoginInfo.objects.filter(
login_type=0, login_key=mdn).count()
if user_login_info_count == 1:
user_login_info = UserLoginInfo.objects.get(login_type=0,
login_key=mdn)
password = user_login_info.login_value
masked_password = password[:3] + (len(password) - 3) * '*'
result.set('password', masked_password)
result.set('guide_message',
'Your password is ' + masked_password)
else:
user_count = User.objects.filter(mdn=mdn).count()
if user_count >= 1:
result.set(
'password',
get_msg(code.ERROR_1301_MDN_ALREADY_EXIST, cn_header))
result.set(
'guide_message',
get_msg(code.ERROR_1301_MDN_ALREADY_EXIST, cn_header))
else:
result.set(
'password',
get_msg(code.ERROR_1302_MDN_INFO_NOT_FOUND, cn_header))
result.set(
'guide_message',
get_msg(code.ERROR_1302_MDN_INFO_NOT_FOUND, cn_header))
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Member info is not found')
return Response(result.get_response(), result.get_code())
def coupon_validate(self, open_id, product_list, coupon_list):
self.logger_info.info(
'[coupon_manager_v2][CouponManagerV2][coupon_validate][' +
open_id + ']')
self.product_list = product_list
self.coupon_list = coupon_list
coupon_service = CouponService(self.logger_info, self.logger_error)
for coupon in coupon_list:
# Get coupon information
coupon_id = coupon['coupon_id']
cs_coupon_ins = coupon_service.read_customer_coupon_ins_with_id(
coupon_id)
coupon_instance = cs_coupon_ins.coupon
coupon_data = coupon_service.read_coupon_data(coupon_instance)
coupon_data['target_product_ids'] = json.loads(
coupon_data['target_product_ids'])
target_id = coupon['target_id']
# Coupon validate
if cs_coupon_ins.open_id != open_id or cs_coupon_ins.status != 0:
self.logger_info.info(code.ERROR_3004_COUPON_OWNER_NOT_FOUND)
error_code = code.ERROR_3004_COUPON_OWNER_NOT_FOUND
raise BusinessLogicError(get_msg(error_code), error_code, None)
coupon_validator = CouponInstance.factory(
coupon_data['coupon_type'], coupon_data, target_id,
product_list)
if not coupon_validator.check_coupon_rule():
error_code = code.ERROR_3005_COUPON_APPLY_ERROR
raise BusinessLogicError(get_msg(error_code), error_code, None)
discount_amount = coupon_validator.get_discount_price()
self.discount_price += discount_amount
coupon_str = payment_util.get_coupon_title_str(
coupon_instance.name, coupon_instance.is_primary_coupon,
target_id, product_list)
coupon_json = {
'coupon_title': coupon_str,
'discount_amount': discount_amount,
'coupon_type': coupon_instance.coupon_type,
'target_type': coupon_instance.target_type,
'target_id': target_id
}
self.coupon_detail.append(coupon_json)
def set_total_price(self, coupon_detail, discount_amount, open_id):
self.order_details['coupons_detail'] = coupon_detail
delivery_price = self.request_data['shipping_cost']
total_price = round((self.product_total_price + discount_amount + delivery_price), 2)
self.logger_info.info(str(self.product_total_price) + ' ' + str(discount_amount) + ' ' +
str(delivery_price) + ' ' + str(total_price))
if float(self.request_data['price_sub_total']) != float(self.product_total_price) \
or -float(self.request_data['price_discount']) != float(discount_amount) \
or float(self.request_data['price_delivery_fee']) != float(delivery_price) \
or float(self.request_data['price_total']) != float(total_price):
error_code = code.ERROR_3006_PAYMENT_PRICE_INVALID
self.logger_error.error(error_code)
raise BusinessLogicError(get_msg(error_code), error_code, None)
self.request_data['order_details'] = json.dumps(self.order_details)
self.request_data['product_list'] = json.dumps(self.request_data['product_list'])
self.request_data['coupon_list'] = json.dumps(self.request_data['coupon_list'])
# Make order response
datetime_now = datetime.now()
telephone = self.request_data['user_telephone']
delivery_date = self.request_data['delivery_date']
hub_id = self.request_data['hub_id']
order_hash = payment_util.get_order_hash(datetime_now, telephone, delivery_date, open_id)
order_id = payment_util.get_order_id(order_hash, open_id, hub_id)
self.order_id = order_id
self.payment_params['order_id'] = order_id
self.request_data['order_hash'] = order_hash
self.request_data['order_id'] = order_id
self.request_data['created_date'] = datetime_now
self.payment_params['total_price'] = total_price
def post(self, request, open_id):
logger_info.info(request.data)
try:
access_token = str(
request.META['HTTP_AUTHORIZATION']).split(' ')[1]
user = User.objects.get(open_id=open_id, access_token=access_token)
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Error : ' + str(e))
return Response(result.get_response(), result.get_code())
request_data = request.data
login_key = request_data['login_key']
login_value = request_data['login_value']
try:
count = UserLoginInfo.objects.filter(
user=user, login_key=login_key,
login_value=login_value).count()
if count != 1:
logger_error.error(
code_msg.get_msg(
code.ERROR_1014_INCORRECT_CURRENT_PASSWORD))
result = ResultResponse.error_response(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(
code.ERROR_1014_INCORRECT_CURRENT_PASSWORD),
code.ERROR_1014_INCORRECT_CURRENT_PASSWORD)
return Response(result.get_response(), result.get_code())
else:
cache.set(login_key, 'password_find', 300)
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())
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
return Response(result.get_response(), result.get_code())
def put(self, request):
request_data = request.data
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
logger_info.info(request_data)
# AUthorization check
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1]
url = urlmapper.get_url('TOKEN_VALIDATE')
headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token}
response = requests.get(url, headers=headers)
if response.status_code != 200:
raise Exception
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_401_UNAUTHORIZED, get_msg(code.ARIES_401_UNAUTHORIZED))
return Response(result.get_response(), result.get_code())
# Request data parsing
try:
# Check selective review object
product_id = request_data['product_id']
comment = request_data['comment']
if len(comment) <= 0:
request_data['visible'] = False
else:
request_data['visible'] = True
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())
review = CustomerReview.objects.get(open_id=open_id, product_id=product_id)
serializer = CustomerReviewSerializer(review, data=request_data, partial=True)
if serializer.is_valid():
serializer.save()
# Statics information apply
payload = {'menu_id': review.menu, 'prev_rate': review.menu_rate,
'menu_rate': request_data['menu_rate']}
statics_result = requests.put(urlmapper.get_url('MENU_STATICS'), json=payload)
logger_info.info(statics_result.text)
else:
logger_info.info(serializer.errors)
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 post(self, request, folder_name):
result = ResultResponse(code.ARIES_200_SUCCESS, 'Upload success')
authentication = header_parser.parse_authentication(request)
if authentication[1] is None:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
get_msg(code.ARIES_401_UNAUTHORIZED))
return Response(result.get_response(), result.get_code())
if not api_request_util.get_user_information(authentication[0],
authentication[1]):
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
get_msg(code.ARIES_401_UNAUTHORIZED))
return Response(result.get_response(), result.get_code())
cdn_manager = CdnManager(request, folder_name=folder_name)
if not cdn_manager.check_file_exists():
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
"File doesn't exists")
return Response(result.get_response(), result.get_code())
if not cdn_manager.check_file_size():
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_1102_FILE_OVERSIZE))
result.set_error(code.ERROR_1102_FILE_OVERSIZE)
return Response(result.get_response(), result.get_code())
if not cdn_manager.get_content_md5():
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
"Get content md5 error")
return Response(result.get_response(), result.get_code())
if not cdn_manager.upload_file():
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
"File upload failed")
return Response(result.get_response(), result.get_code())
return Response(result.get_response(), result.get_code())
def get_login_info(self):
# MDN quick login
login_key = self.login_data['login_key']
login_value = self.login_data['login_value']
# Check SMS authentication
url = urlmapper.get_url('USER_SMS_VERIFICATION')
payload = {'mdn': login_key, 'verification_code': login_value}
response = requests.post(url, json=payload)
if response.status_code == code.ARIES_200_SUCCESS:
try:
user_instance = User.objects.get(mdn=login_key)
except Exception as e:
print(e)
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(
code.ERROR_1005_USER_ALREADY_REGISTRATION))
result.set_error(code.ERROR_1005_USER_ALREADY_REGISTRATION)
logger_error.error(
code_msg.get_msg(
code.ERROR_1005_USER_ALREADY_REGISTRATION))
return Response(result.get_response(), result.get_code())
else:
login_info = UserLoginInfo.objects.filter(
user=user_instance).exclude(
login_key__icontains='dormant')[0]
login_id = login_info.id
login_info = UserLoginInfo.objects.filter(id=login_id)[0]
result = (login_info, login_key, False)
return result
else:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(1003))
result.set_error(code.ERROR_1003_SMS_VERIFICATION_FAILURE)
return Response(result.get_response(), result.get_code())
def delete(self, request):
request_data = request.data
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
logger_info.info(request_data)
# AUthorization check
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1]
url = urlmapper.get_url('TOKEN_VALIDATE')
headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token}
response = requests.get(url, headers=headers)
if response.status_code != 200:
raise Exception
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_401_UNAUTHORIZED, get_msg(code.ARIES_401_UNAUTHORIZED))
return Response(result.get_response(), result.get_code())
# Request data parsing
try:
product_id = request_data['product_id']
order_id = request_data['order_id']
review = CustomerReview.objects.get(open_id=open_id, product_id=product_id, order_id=order_id)
# Statics information apply
payload = {'menu_id': review.menu, 'prev_rate': review.menu_rate}
statics_result = requests.delete(urlmapper.get_url('MENU_STATICS'), json=payload)
logger_info.info(statics_result.text)
review.delete()
return Response(result.get_response(), result.get_code())
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())
def product_validate(self, product):
try:
product_instance = Product.objects.get(id=product['product_id'])
menu_instance = Menu.objects.using(
self.target_db).get(id=product_instance.menu.id)
except Exception as e:
print(e)
result = (False, None)
return result
# Product quantity
order_quantity = product['quantity']
stock = product_instance.stock
if stock < order_quantity:
error_message = get_msg(code.ERROR_3001_PRODUCT_ALREADY_SOLD,
self.cn_header)
error_message = error_message + ' [' + menu_instance.name + ']'
result = (False, error_message)
return result
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
logger_info.info(request_data)
try:
access_token = request_data['access_token']
access_token = access_token.split(' ')[1]
scope = request_data['scope']
token_count = AuthToken.objects.filter(access_token=access_token,
scope=scope).count()
if token_count <= 0:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
get_msg(code.ARIES_401_UNAUTHORIZED))
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid')
return Response(result.get_response(), result.get_code())
def post(self, request):
print(request.data)
request_data = request.data
logger_info.info(request_data)
sign_obj = Sign()
# Get access token
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(
request.META['HTTP_AUTHORIZATION']).split(' ')[1]
sign_obj.login_type = request_data['login_type']
sign_obj.login_sns_open_id = request_data['login_sns_open_id']
sign_obj.login_sns_access_token = request_data[
'login_sns_access_token']
sign_obj.login_sns_refresh_token = ''
user = User.objects.get(open_id=open_id, access_token=access_token)
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Token or user not found')
return Response(result.get_response(), result.get_code())
if sign_obj.login_type == 0:
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Not supported connect method')
return Response(result.get_response(), result.get_code())
# Check login information
try:
if sign_obj.login_type == 1:
# In case of QQ
login_info_count = UserLoginInfo.objects.filter(
login_sns_open_id=sign_obj.login_sns_open_id).count()
if login_info_count >= 1:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(
code.ERROR_1010_USER_ALREADY_CONNECTION))
result.set_error(code.ERROR_1010_USER_ALREADY_CONNECTION)
return Response(result.get_response(), result.get_code())
UserLoginInfo.objects.create(
user=user,
login_type=sign_obj.login_type,
login_key=sign_obj.login_key,
login_value=sign_obj.login_value,
login_sns_open_id=sign_obj.login_sns_open_id,
login_sns_access_token=sign_obj.login_sns_access_token,
login_sns_refresh_token=sign_obj.login_sns_refresh_token)
user.connection_count += 1
connect_info = json.loads(user.connection_account)
new_info = {
'login_type': sign_obj.get_login_type(),
'login_sns_open_id': sign_obj.login_sns_open_id
}
connect_info.append(new_info)
user.connection_account = json.dumps(connect_info)
user.save()
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('login_type', sign_obj.get_login_type())
result.set('login_sns_open_id',
sign_obj.login_sns_access_token)
return Response(result.get_response(), result.get_code())
elif sign_obj.login_type == 2 or sign_obj.login_type == 3:
# WeChat SNS login
login_sns_open_id = request_data['login_sns_open_id']
if sign_obj.login_type == 2:
# WeChat app login
payload = {
'appid': 'wx87010cb61b99206d',
'secret': '21b9cf8d51b704fd244f40b351d7876e',
'code': login_sns_open_id,
'grant_type': 'authorization_code'
}
else:
# WeChat public account login
payload = {
'appid': 'wx41b86399fee7a2ec',
'secret': '1b3d5dce9860be7e4fc04847df6a6177',
'code': login_sns_open_id,
'grant_type': 'authorization_code'
}
sign_obj.login_type = 2
response = requests.get(resources.WECHAT_ACCESS_TOKEN_URL,
params=payload)
if response.status_code != code.ARIES_200_SUCCESS:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(
code.ERROR_1011_ACCESS_TOKEN_GET_FAIL))
result.set_error(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)
logger_error.error(
code_msg.get_msg(
code.ERROR_1011_ACCESS_TOKEN_GET_FAIL))
return Response(result.get_response(), result.get_code())
response_json = response.json()
print(response.text)
if response_json.get('unionid'):
sign_obj.login_key = response_json['openid']
sign_obj.login_value = ''
sign_obj.login_sns_open_id = response_json['unionid']
sign_obj.login_sns_access_token = response_json[
'access_token']
sign_obj.login_sns_refresh_token = response_json[
'refresh_token']
wechat_count = UserLoginInfo.objects.filter(
login_type=sign_obj.login_type,
login_sns_open_id=sign_obj.login_sns_open_id).count()
if wechat_count >= 1:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(
code.ERROR_1010_USER_ALREADY_CONNECTION))
result.set_error(
code.ERROR_1010_USER_ALREADY_CONNECTION)
logger_error.error(
code_msg.get_msg(
code.ERROR_1010_USER_ALREADY_CONNECTION))
return Response(result.get_response(),
result.get_code())
else:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(
code.ERROR_1011_ACCESS_TOKEN_GET_FAIL))
result.set_error(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)
logger_error.error(
code_msg.get_msg(
code.ERROR_1011_ACCESS_TOKEN_GET_FAIL))
return Response(result.get_response(), result.get_code())
UserLoginInfo.objects.create(
user=user,
login_type=sign_obj.login_type,
login_key=sign_obj.login_key,
login_value=sign_obj.login_value,
login_sns_open_id=sign_obj.login_sns_open_id,
login_sns_access_token=sign_obj.login_sns_access_token,
login_sns_refresh_token=sign_obj.login_sns_refresh_token)
user.connection_count += 1
connect_info = json.loads(user.connection_account)
new_info = {
'login_type': sign_obj.get_login_type(),
'login_sns_open_id': sign_obj.login_sns_open_id
}
connect_info.append(new_info)
user.connection_account = json.dumps(connect_info)
user.save()
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('login_type', sign_obj.get_login_type())
result.set('login_sns_open_id', sign_obj.login_sns_open_id)
return Response(result.get_response(), result.get_code())
elif sign_obj.login_type == 4:
# QQ mobile web connect
login_sns_open_id = request_data['login_sns_open_id']
payload = {
'grant_type':
'authorization_code',
'client_id':
'1106290901',
'client_secret':
'WbcNyj80WeBvgoSs',
'code':
login_sns_open_id,
'redirect_uri':
'https://api.viastelle.com/users/signin/callback'
}
response = requests.get(resources.QQ_ACCESS_TOKEN_URL,
params=payload)
print(response.text)
res_text = response.text
if 'access_token' in res_text:
res_json = json.loads(json.dumps(parse_qs(res_text)))
qq_access_token = res_json['access_token'][0]
qq_exprires_in = res_json['expires_in'][0]
qq_refresh_token = res_json['refresh_token'][0]
payload = {'access_token': qq_access_token}
response = requests.get(resources.QQ_OPEN_ID_URL,
params=payload)
res_text = response.text
logger_info.info(res_text)
split_res = res_text.split(' ')
json_result = json.loads(split_res[1])
response_openid = json_result['openid']
login_sns_access_token = response_openid
qq_count = UserLoginInfo.objects.filter(
login_sns_open_id=login_sns_access_token).count()
if qq_count >= 1:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(
code.ERROR_1010_USER_ALREADY_CONNECTION))
result.set_error(
code.ERROR_1010_USER_ALREADY_CONNECTION)
logger_error.error(
code_msg.get_msg(
code.ERROR_1010_USER_ALREADY_CONNECTION))
return Response(result.get_response(),
result.get_code())
UserLoginInfo.objects.create(
user=user,
login_type=sign_obj.get_login_type(),
login_key='',
login_value='',
login_sns_open_id=login_sns_access_token,
login_sns_access_token=qq_access_token,
login_sns_refresh_token=qq_refresh_token)
else:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_1101_NOT_SUPPORTED_FILE_FORMAT))
result.set_error(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)
logger_error.error(
get_msg(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL))
return Response(result.get_response(), result.get_code())
user.connection_count += 1
connect_info = json.loads(user.connection_account)
new_info = {
'login_type': sign_obj.get_login_type(),
'login_sns_open_id': login_sns_access_token
}
connect_info.append(new_info)
user.connection_account = json.dumps(connect_info)
user.save()
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('login_type', sign_obj.get_login_type())
result.set('login_sns_open_id', login_sns_access_token)
return Response(result.get_response(), result.get_code())
else:
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid')
return Response(result.get_response(), result.get_code())
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_400_BAD_REQUEST, e)
return Response(result.get_response(), result.get_code())
def put(self, request):
request_data = request.data
logger_info.info(request_data)
sign_obj = Sign()
# Get access token
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(
request.META['HTTP_AUTHORIZATION']).split(' ')[1]
sign_obj.login_type = request_data['login_type']
sign_obj.login_sns_open_id = request_data['login_sns_open_id']
sign_obj.login_sns_access_token = ''
sign_obj.login_sns_refresh_token = ''
user = User.objects.get(open_id=open_id, access_token=access_token)
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Token or user not found')
return Response(result.get_response(), result.get_code())
try:
login_info = UserLoginInfo.objects.filter(
user=user, login_sns_open_id=sign_obj.login_sns_open_id)
count = UserLoginInfo.objects.filter(user=user).count()
if (count - login_info.count()) <= 0:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(code.ERROR_1013_ONLY_ONE_LOGIN_INFO))
result.set_error(code.ERROR_1013_ONLY_ONE_LOGIN_INFO)
logger_error.error(
code_msg.get_msg(code.ERROR_1013_ONLY_ONE_LOGIN_INFO))
return Response(result.get_response(), result.get_code())
if login_info.count() == 1:
login_info = UserLoginInfo.objects.get(
user=user, login_sns_open_id=sign_obj.login_sns_open_id)
login_info.delete()
if user.connection_count == 2 and user.parent_type != 0:
# Full connection count - WeChat, QQ
# Delete success and change access_token
if sign_obj.login_type == 1 or sign_obj.login_type == 4:
# Delete QQ account, get a wechat account
new_login_info = UserLoginInfo.objects.get(
user=user, login_type=2)
else:
# Delete wechat account, get a qq account
new_login_info = UserLoginInfo.objects.get(
user=user, login_type=1)
payload = {
'user_open_id': open_id,
'user_account': login_info.login_sns_open_id,
'new_user_account': new_login_info.login_sns_open_id
}
response = requests.put(
urlmapper.get_url('PLATFORM_SERVER'), json=payload)
logger_info.info(response.text)
connect_info = json.loads(user.connection_account)
logger_info.info(connect_info)
if connect_info.remove({
'login_type':
sign_obj.login_type,
'login_sns_open_id':
sign_obj.login_sns_open_id
}):
user.connection_account = json.dumps(connect_info)
user.connection_count -= 1
user.save()
else:
user.connection_account = json.dumps(connect_info)
user.connection_count -= 1
user.save()
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('login_type', sign_obj.login_type)
result.set('login_sns_open_id', sign_obj.login_sns_open_id)
return Response(result.get_response(), result.get_code())
else:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(code.ERROR_1012_LOGIN_INFO_NOT_FOUND))
result.set_error(code.ERROR_1012_LOGIN_INFO_NOT_FOUND)
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, e)
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS_MSG)
language_info = header_parser.parse_language(request.META)
cn_header = language_info[0]
target_db = language_info[1]
result_list = list()
result_product_list = list()
try:
request_data = request.data
os_type = request_data.get('os_type', 0)
hub_id = request_data.get('hub_id', 1)
product_list = request.data['product_list']
delivery_schedule = request.data['delivery_schedule']
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())
first_product = True
product_order_name = ''
sales_time = 0
# Time bomb service
product_service = ProductService(logger_info, logger_error)
time_bomb_service = TimeBombService(logger_info, logger_error)
time_bomb_id = time_bomb_service.get_current_time_bomb_id(hub_id, os_type)
discount_info = {}
if time_bomb_id is not None:
discount_list = product_service.read_product_discount_info_with_id(time_bomb_id)
discount_info.update(get_discount_info_map(discount_list, cn_header))
for product in product_list:
try:
product_instance = Product.objects.get(id=product['product_id'])
menu_instance = Menu.objects.using(target_db).get(id=product_instance.menu.id)
hub_stock = HubStock.objects.get(hub=product_instance.hub, menu=menu_instance)
# Check sales_time
sales_time = product_instance.sales_time
# Check real stock unit
order_quantity = product['quantity']
stock = hub_stock.stock
if stock < order_quantity:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Product already sold')
error_code = code.ERROR_3001_PRODUCT_ALREADY_SOLD
result.set_error(error_code)
error_message = get_msg(error_code, cn_header)
error_message += ' [' + menu_instance.name + ']'
result.set_error_message(error_message)
return Response(result.get_response(), result.get_code())
# Check schedule time
if not check_delivery_schedule(delivery_schedule):
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Schedule invalid')
error_code = code.ERROR_3015_PRODUCT_DELIVERY_TIME_INVALID
error_message = get_msg(error_code, cn_header)
result.set_error(error_code)
result.set_error_message(error_message)
return Response(result.get_response(), result.get_code())
# Product information
product_serializer = ProductListInfoSerializer(product_instance)
product_data = product_serializer.data
menu_serializer = MenuValidationSerializer(menu_instance)
menu_data = menu_serializer.data
product_data['menu'] = menu_data
product_data['quantity'] = product['quantity']
# Add time bomb information
if product_data['id'] in discount_info:
add_discount_information(product_data, discount_info[product_data['id']])
result_product_list.append(product_data)
if first_product:
product_order_name = product_instance.menu.name
# product_order_name = menu_instance.name
first_product = False
logger_info.info(str(stock) + ' ' + str(product['quantity']))
if stock >= product['quantity']:
result_list.append(product['product_id'])
except Exception as e:
print(e)
result.set('product_title', product_order_name)
# Check if result list is zero, don't display more
if int(len(result_list)-1) != 0:
result.set('product_sub', '(and ' + str(len(result_list)-1) + ' more)')
else:
result.set('product_sub', '')
result.set('sales_time', sales_time)
result.set('product_count', len(result_list))
result.set('product_index_list', result_list)
result.set('product_list', result_product_list)
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
logger_info.info(request_data)
mdn = request_data['mdn']
is_english = True
if request.META.get('HTTP_ACCEPT_LANGUAGE'):
accept_lang = request.META['HTTP_ACCEPT_LANGUAGE']
if 'zh' in accept_lang:
is_english = False
if len(mdn) <= 10:
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid')
return Response(result.get_response(), result.get_code())
if 'sms_type' in request_data and request_data['sms_type'] == 1:
user_count = User.objects.filter(mdn=mdn).count()
del request_data['sms_type']
if user_count >= 1:
error_code = code.ERROR_1005_USER_ALREADY_REGISTRATION
result_msg = get_msg(error_code, not is_english)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
result_msg)
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
user_count = User.objects.filter(mdn=mdn).count()
serializer = UserSmsSerializer(data=request_data)
if serializer.is_valid():
user_model = serializer.data
self.verification_code = '%06d' % random.randint(1, 999999)
today = datetime.datetime.today()
sms_auth_history = SmsAuthHistory.objects.create(
date=today,
target_mdn=mdn,
verification_code=self.verification_code,
has_verified=False)
if sms_auth_history is None:
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid')
return Response(result.get_response(), result.get_code())
sender = SmsSender(user_model.get('mdn'), self.verification_code,
is_english)
sender.start()
cache.set(user_model.get('mdn'), self.verification_code, 70)
if user_count >= 1:
result.set('member_check', True)
else:
result.set('member_check', False)
else:
logger_info.info('Request data invalid')
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid')
return Response(result.get_response(), result.get_code())
logger_info.info(result.get_response())
return Response(result.get_response(), status=result.get_code())
def delete(self, request, order_id):
# Request data parsing
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1]
logger_info.info(open_id + ':' + access_token + ':' + order_id)
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())
# Get purchase order instance
try:
order = Order.objects.get(open_id=open_id, order_id=order_id)
purchase_order = PurchaseOrder.objects.get(open_id=open_id, order_id=order.order_id)
except Exception as e:
logger_error.error(str(e))
error_code = code.ERROR_3002_PURCHASE_ORDER_NOT_FOUND
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
# Check order status to edit
if order.order_status != 0:
error_code = code.ERROR_3009_ORDER_EDIT_NOT_AVAILABLE
logger_error.error(error_code)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
# Refund payment
header = {'open-id': open_id}
url = urlmapper.get_url('PAYMENT') + '/' + order_id + '/detail'
response = requests.delete(url, headers=header)
order.order_status = 11
order_history = json.loads(order.order_status_history)
order_history.append(dateformatter.get_order_status_history(11))
order.order_status_history = json.dumps(order_history)
order.operation_status = 10
order_operation_history = json.loads(order.operation_status_history)
order_operation_history.append(dateformatter.get_order_status_history(10))
order.operation_status_history = json.dumps(order_operation_history)
# Add order cancel date
order.order_cancel_date = datetime.today()
order.save()
if response.status_code != code.ARIES_200_SUCCESS:
purchase_order.status = 6
purchase_order.save()
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4003_PAYMENT_REFUND_FAIL))
result.set_error(code.ERROR_4003_PAYMENT_REFUND_FAIL)
return Response(result.get_response(), result.get_code())
else:
# Refund success
purchase_order.status = 5
purchase_order.save()
# Coupon restore
coupon_list = json.loads(purchase_order.coupon_list)
for coupon in coupon_list:
coupon_id = coupon['coupon_id']
coupon = CustomerCoupon.objects.get(id=coupon_id)
current_date = date.today()
if current_date <= coupon.end_date:
coupon.status = 0
coupon.used_date = current_date
coupon.save()
url = urlmapper.get_url('USER_NOTIFICATION') + '/coupon/0/1'
headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token}
requests.get(url, headers=headers)
else:
coupon.status = 2
coupon.used_date = current_date
coupon.save()
# Product stock update
product_list = json.loads(purchase_order.product_list)
payload = {'trade_type': 1, 'product_list': product_list, 'validate_str': 'GoDbAcKeNdS'}
url = urlmapper.get_url('PRODUCT_STOCK')
response = requests.post(url, json=payload)
logger_info.info(response.text)
# Order canceled
headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token}
payload = {'order_id': order_id}
url = urlmapper.get_url('OPERATION_ORDER_CANCELED')
response = requests.post(url, headers=headers, json=payload)
logger_info.info(response.text)
# First purchase canceled
first_purchase_count = EventOrderHistory.objects.filter(open_id=open_id).count()
if first_purchase_count == 1:
first_purchase = EventOrderHistory.objects.get(open_id=open_id)
first_purchase.event_target = False
first_purchase.save()
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
return Response(result.get_response(), result.get_code())
def post(self, request, folder_name):
print(request.META)
print(request.FILES)
result = ResultResponse(code.ARIES_200_SUCCESS, 'Upload success')
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(
request.META['HTTP_AUTHORIZATION']).split(' ')[1]
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Token or open id invalid')
return Response(result.get_response(), result.get_code())
if 'file' in request.FILES:
# File object create
file = request.FILES['file']
fs = FileSystemStorage()
filename = fs.save(file.name, file)
# File size check
file_size = file.size
if file_size >= self.MEGA * 5:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_1102_FILE_OVERSIZE))
result.set_error(code.ERROR_1102_FILE_OVERSIZE)
return Response(result.get_response(), result.get_code())
# File name information processing
uploaded_file_url = fs.path(filename)
upload_filename = self.make_file_name(filename)
upload_file_ext = filename.split('.')[-1]
upload_name = folder_name + '/' + upload_filename
print(upload_name)
# Check file format to png or jpg
if upload_file_ext.lower() != 'png' and upload_file_ext.lower() != 'jpg'\
and upload_file_ext.lower() != 'jpeg':
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL))
result.set_error(code.ERROR_1101_NOT_SUPPORTED_FILE_FORMAT)
print('Error')
fs.delete(filename)
return Response(result.get_response(), result.get_code())
url = 'http://viastelle-user-storage.oss-cn-shanghai.aliyuncs.com/' + upload_name
host = 'viastelle-user-storage.oss-cn-shanghai.aliyuncs.com'
hash_value = hashlib.md5()
with open(uploaded_file_url, 'rb') as mdfile:
for buf in iter(partial(mdfile.read, 128), b''):
hash_value.update(buf)
content_md5 = base64.b64encode(hash_value.digest()).decode('utf-8')
headers = {
'Content-MD5':
content_md5,
'Content-Length':
str(file_size),
'Content-Type':
'image/' + upload_file_ext,
'Host':
host,
'Date':
oss.get_gmt_date(),
'Authorization':
oss.get_oss_header(
upload_filename, 'PUT', content_md5, upload_file_ext,
'/viastelle-user-storage/' + folder_name + '/')
}
with open(uploaded_file_url, 'rb') as upload_file:
data = upload_file.read()
response = requests.put(url, headers=headers, data=data)
if response.status_code is 200:
result.set('file_name', upload_name)
# Check profile image
if folder_name.lower() == 'profile':
url = urlmapper.get_url(
'USER_INFO') + '/' + open_id + '/detail'
headers = {
'AUTHORIZATION': 'bearer ' + access_token,
'OPEN-ID': open_id
}
payload = {'profile_image': upload_name}
user_response = requests.put(url,
headers=headers,
json=payload)
print(user_response.text)
else:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
"File upload fail")
fs.delete(filename)
else:
print('no file!!')
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
"File upload fail")
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
logger_info.info(request_data)
language_info = header_parser.parse_language(request.META)
cn_header = language_info[0]
order_data = dict()
coupon_instance_list = list()
# for getting daily order index
order_manager_v2 = OrderManagerV2(logger_info, logger_error)
# Step 1. Request data parsing
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1]
order_id = request_data['order_id']
payment_data = request_data['payment_data']
notification_order = request_data.get('alipay_notification_order', False)
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid(Token or Open id)')
return Response(result.get_response(), result.get_code())
# Step 1.5
order_count = Order.objects.filter(order_id=order_id, open_id=open_id).count()
if order_count == 1:
order = Order.objects.get(order_id=order_id, open_id=open_id)
purchase_order = PurchaseOrder.objects.get(order_id=order_id, open_id=open_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']
order_data = UpcomingOrderSerializer(order).data
order_data['order_start_date'] = dateformatter.get_ordering_complete_date_fmt(order.order_start_date)
order_data['order_status_history'] = json.loads(order_data['order_status_history'])
order_data['purchase_order'] = purchase_order_data
order_data['order_cancel_date'] = ''
# Get Timetable
order_data['timetable'] = json.loads('[]')
result.set('upcoming_order', order_data)
return Response(result.get_response(), result.get_code())
# Step 2. Check payment data validation and coupon check
try:
purchase_order = PurchaseOrder.objects.get(order_id=order_id, open_id=open_id,
status=self.PURCHASE_ORDER_STATUS_CREATED)
order_data['purchase_order'] = purchase_order.id
payment_type = purchase_order.payment_type
# Check payment data validation
payload = {'open_id': open_id, 'order_id': order_id, 'payment_type': payment_type,
'payment_raw_data': payment_data, 'price_unit': purchase_order.price_unit,
'price_total': purchase_order.price_total}
if notification_order:
payload['notification_order'] = True
else:
payload['notification_order'] = False
payment_url = payment_util.get_payment_app_url(purchase_order.payment_type)
response = requests.post(payment_url, json=payload)
logger_info.info(response.text)
payment_result = response.json()
if response.status_code != code.ARIES_200_SUCCESS:
if response.status_code == code.ARIES_400_BAD_REQUEST:
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
get_msg(code.ERROR_9000_INTERNAL_API_CALL_FAILED, cn_header))
elif payment_result['error_code'] == code.ERROR_4001_PAYMENT_VALIDATION_FAILED:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4001_PAYMENT_VALIDATION_FAILED, cn_header))
result.set_error(code.ERROR_4001_PAYMENT_VALIDATION_FAILED)
elif payment_result['error_code'] == code.ERROR_4005_PAYMENT_SYNC_ERROR:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4005_PAYMENT_SYNC_ERROR, cn_header))
purchase_order.status = 3
purchase_order.save()
return Response(result.get_response(), result.get_code())
logger_info.info('Payment finished')
# Order saved and coupon using section
coupon_list = json.loads(purchase_order.coupon_list)
logger_info.info(coupon_list)
for coupon in coupon_list:
coupon_id = coupon['coupon_id']
coupon_count = CustomerCoupon.objects.filter(id=coupon_id).count()
if coupon_count == 1:
coupon_instance = CustomerCoupon.objects.get(id=coupon_id)
coupon_instance.status = 1
coupon_instance.used_date = datetime.now()
coupon_instance_list.append(coupon_instance)
else:
logger_error.error(get_msg(code.ERROR_4001_PAYMENT_VALIDATION_FAILED))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4001_PAYMENT_VALIDATION_FAILED))
result.set_error(code.ERROR_4001_PAYMENT_VALIDATION_FAILED)
purchase_order.status = 3
purchase_order.save()
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_error.error(str(e))
error_code = code.ERROR_3002_PURCHASE_ORDER_NOT_FOUND
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code), cn_header)
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
# Step 3 Order data section
logger_info.info('Order data section')
# Order data
order_data['open_id'] = open_id
order_data['hub_id'] = purchase_order.hub_id
order_data['order_id'] = order_id
order_data['order_status'] = self.ORDER_STATUS_CREATED
history_date = dateformatter.get_yyyymmdd_now()
history_payload = [{'status': 0, 'datetime': history_date}]
order_data['order_status_history'] = json.dumps(history_payload)
order_data['order_daily_index'] = order_manager_v2.get_daily_order_index()
# Delivery data
is_on_site_pickup = purchase_order.delivery_on_site
address_id = purchase_order.delivery_address_id
# Check if it was on-site pickup or not
if is_on_site_pickup:
logger_info.info('On site pickup')
hub_name = hub_data.get_hub_name(cn_header, purchase_order.hub_id)
complete_address = hub_name + '\n - ' + hub_data.get_hub_address(cn_header, purchase_order.hub_id)
order_data['delivery_on_site'] = purchase_order.delivery_on_site
order_data['delivery_address'] = complete_address
else:
logger_info.info('NOT on site pickup')
try:
headers = {'open-id': str(open_id), 'authorization': 'bearer ' + access_token,
'Content-Type': 'application/json'}
response = requests.get(urlmapper.get_url('PRODUCT_ADDRESS_DETAIL') + '/' + str(address_id),
headers=headers)
except Exception as e:
logger_info.info(str(e))
if response.status_code == code.ARIES_200_SUCCESS:
response_json = response.json()['user_address']
logger_info.info(response_json)
# Set delivery address
recipient_name = response_json['recipient_name']
recipient_mdn = response_json['recipient_mdn']
if len(recipient_mdn) <= 0 and len(recipient_name) <= 0:
delivery_address = response_json['name']
else:
delivery_address = response_json['name'] + ' - ' + response_json['detail']
if len(delivery_address) > 300:
delivery_address = delivery_address[:300]
order_data['delivery_address'] = delivery_address
order_data['delivery_address_lat'] = response_json['latitude']
order_data['delivery_address_lng'] = response_json['longitude']
order_data['delivery_recipient_name'] = recipient_name
order_data['delivery_recipient_mdn'] = recipient_mdn
else:
# New address check
logger_info.info('Address not found error')
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
'Address not found')
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
return Response(result.get_response(), result.get_code())
logger_info.info('After on site pickup')
order_data['user_name'] = purchase_order.user_name
order_data['user_telephone'] = purchase_order.user_telephone
order_data['user_receipt'] = purchase_order.user_receipt
order_data['delivery_date'] = purchase_order.delivery_date
order_data['delivery_schedule'] = purchase_order.delivery_schedule
order_data['delivery_as_fast'] = purchase_order.delivery_as_fast
order_data['delivery_customer_name'] = purchase_order.user_name
order_data['delivery_telephone_state'] = 0
order_data['delivery_telephone'] = 'Delivery telephone'
pre_time = purchase_order.delivery_start_time
post_time = purchase_order.delivery_end_time
delivery_date = str(purchase_order.delivery_date).replace('-', '.')
order_data['delivery_time'] = delivery_date + ', ' + pre_time + '~' + post_time
# Shipping data
order_data['shipping_method'] = purchase_order.shipping_method
order_data['shipping_status'] = 0
# Step 4
logger_info.info('STEP 4')
order_count = Order.objects.filter(order_id=order_id, open_id=open_id).count()
if order_count == 1:
logger_info.info('Order exists')
order = Order.objects.get(order_id=order_id, open_id=open_id)
purchase_order = PurchaseOrder.objects.get(order_id=order_id, open_id=open_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']
order_data = UpcomingOrderSerializer(order).data
order_data['order_start_date'] = dateformatter.get_ordering_complete_date_fmt(order.order_start_date)
order_data['order_status_history'] = json.loads(order_data['order_status_history'])
order_data['purchase_order'] = purchase_order_data
order_data['order_cancel_date'] = ''
# Get Timetable
order_data['timetable'] = json.loads('[]')
result.set('upcoming_order', order_data)
return Response(result.get_response(), result.get_code())
# Step 5
# Create order object and send order data to client
logger_info.info('Step 5')
try:
order_serializer = OrderSerializer(data=order_data)
if order_serializer.is_valid():
order_serializer.save()
logger_info.info('Order valid and save success')
# Order save success and coupon save
for coupon_ins in coupon_instance_list:
coupon_ins.save()
# User notification url call
url = urlmapper.get_url('USER_NOTIFICATION') + '/coupon/1/' + str(len(coupon_instance_list))
headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token}
requests.get(url, headers=headers)
# Get special instruction and include cutlery information
include_cutlery = purchase_order.include_cutlery
special_inst = purchase_order.special_instruction
# Special instruction and include cutlery save call
url = urlmapper.get_url('USER_CART_INFO_SAVE')
headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token}
json_data = {'include_cutlery': include_cutlery, 'special_instruction': special_inst}
requests.put(url, headers=headers, json=json_data)
# After user notification
logger_info.info('After user notification request')
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']
order_data = order_serializer.data
order = Order.objects.get(id=order_data['id'])
order_data = UpcomingOrderSerializer(order).data
order_data['order_start_date'] = dateformatter.get_ordering_complete_date_fmt(order.order_start_date)
order_data['order_status_history'] = json.loads(order_data['order_status_history'])
order_data['purchase_order'] = purchase_order_data
order_data['order_cancel_date'] = ''
# Get Timetable
logger_info.info('Get time table')
order_data['timetable'] = json.loads('[]')
result.set('upcoming_order', order_data)
# Check on first purchase
logger_info.info('Check first purchase')
first_order_count = Order.objects.filter(open_id=open_id, order_status__lte=10).count()
if first_order_count == 1:
hub_id = purchase_order.hub_id
event_order_service = EventOrderService(logger_info, logger_error)
event_order_service.create_event_order(0, hub_id, open_id, order_id)
else:
logger_error.error(order_serializer.errors)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Internal server error')
return Response(result.get_response(), result.get_code())
purchase_order.status = 1
purchase_order.save()
logger_info.info('Purchase order save')
# Product stock update
product_list = json.loads(purchase_order.product_list)
payload = {'trade_type': 0, 'product_list': product_list, 'validate_str': 'GoDbAcKeNdS'}
url = urlmapper.get_url('PRODUCT_STOCK')
response = requests.post(url, json=payload)
logger_info.info(response.text)
# Order complete
headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token}
payload = {'order_id': order_id}
url = urlmapper.get_url('OPERATION_ORDER_COMPLETE')
response = requests.post(url, headers=headers, json=payload)
logger_info.info(response.text)
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Internal server error')
return Response(result.get_response(), result.get_code())
# Step 6
# Save payment method and notify to admin server
# Upcoming order notification added
logger_info.info('Step 6')
headers = {'AUTHORIZATION': request.META['HTTP_AUTHORIZATION']}
payload = {'latest_payment_method': purchase_order.payment_type}
url = urlmapper.get_url('USER_INFO') + '/' + open_id + '/info'
response = requests.put(url, headers=headers, json=payload)
logger_info.info(response.json())
try:
# Hub message
logger_info.info('Hub message')
order_manager = OrderManager(logger_info, logger_error)
order_list_detail = order_manager.get_order_list(order_id)
payload = {
'code': 200, 'message': 'success', 'order': order_list_detail, 'type': 1,
'order_id': order_id, 'title': 'Here comes a new order'
}
url = urlmapper.get_url('HUB_MESSAGE_ANDROID')
response = requests.post(url, json=payload)
logger_info.info(response.text)
except Exception as e:
logger_info.info(str(e))
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
logger_info.info(request_data)
# Payment registration and validation check
try:
payment_type = request_data['payment_type']
order_id = request_data['order_id']
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())
# Check if the payment exists
payment_count = Payment.objects.filter(order_id=order_id).count()
if payment_count != 0:
payment = Payment.objects.get(order_id=order_id)
if payment.payment_status == 0 or payment.payment_status == 1:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
return Response(result.get_response(), result.get_code())
# Get raw data for validation
raw_data = {}
# Wechat app payment
request_data['payment_raw_data'] = json.dumps(raw_data)
try:
wechat_serializer = WechatPaymentSerializer(data=request_data)
if wechat_serializer.is_valid():
wechat_serializer.save()
else:
logger_info.info(wechat_serializer.errors)
except Exception as e:
print(e)
logger_info.info(str(e))
if payment_type == 1:
wechat_app_id = 'viastelle'
merchant_id = 'viastelle'
api_key = 'viastelle'
nonce_str = payment_util.wechat_payment_str(order_id)
else:
wechat_app_id = 'viastelle'
merchant_id = 'viastelle'
api_key = 'viastelle'
nonce_str = payment_util.wechat_payment_str(order_id)
wechat_client = WeChatPay(wechat_app_id,
api_key,
merchant_id,
sub_mch_id=None,
mch_cert=None,
mch_key=None)
try:
query_data = {
'appid': wechat_app_id,
'mch_id': merchant_id,
'out_trade_no': order_id,
'nonce_str': nonce_str
}
prepaid_signature = utils.calculate_signature(query_data, api_key)
query_data_signed = utils.dict_to_xml(query_data,
prepaid_signature)
url = get_wechat_query_url()
headers = {'Content-Type': 'application/xml'}
response = requests.post(url,
headers=headers,
data=query_data_signed)
logger_info.info(response.text)
response_data = response.content
query_result = xmltodict.parse(response_data)['xml']
query_result['order_id'] = order_id
request_data['transaction_id'] = query_result['transaction_id']
query_serializer = WechatQuerySerializer(data=query_result)
if query_serializer.is_valid():
query_serializer.save()
query_data = query_serializer.data
else:
logger_info.info(query_serializer.errors)
# Error case - refund request
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4005_PAYMENT_SYNC_ERROR))
result.set_error(code.ERROR_4005_PAYMENT_SYNC_ERROR)
return Response(result.get_response(), result.get_code())
# Set payment status
request_data['payment_status'] = self.PAYMENT_CREATED
payment_serializer = PaymentSerializer(data=request_data)
# Payment object save
if payment_serializer.is_valid():
payment_serializer.save()
payment = Payment.objects.get(order_id=order_id)
else:
logger_info.info(payment_serializer.errors)
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid')
return Response(result.get_response(), result.get_code())
# Verification payment
if payment_type == self.WECHAT_APP_PAYMENT or payment_type == self.WECHAT_MOBILE_PAYMENT:
if query_data['return_code'] == 'SUCCESS' and query_data[
'result_code'] == 'SUCCESS':
# Payment success and check price
# if query_data['total_fee'] == int(price_total):
del query_result['order_id']
if not wechat_client.check_signature(query_result):
payment.payment_status = 4
else:
payment.payment_status = 1
payment.save()
else:
payment.payment_status = 4
payment.save()
logger_error.error(code.ERROR_4001_PAYMENT_VALIDATION_FAILED)
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4001_PAYMENT_VALIDATION_FAILED))
result.set_error(code.ERROR_4001_PAYMENT_VALIDATION_FAILED)
return Response(result.get_response(), result.get_code())
else:
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 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 delete(self, request, order_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
logger_info.info(request_data)
# Request data parsing
try:
open_id = request.META['HTTP_OPEN_ID']
payment = Payment.objects.get(open_id=open_id, order_id=order_id)
except Exception as e:
logger_error.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid')
return Response(result.get_response(), result.get_code())
payment_type = payment.payment_type
# Refund business logic
if payment_type == 0 or payment_type == 2:
alipay_transaction = AlipayPaymentTransaction.objects.get(
out_trade_no=order_id)
# Check debug state value
if settings.STAGE or settings.DEBUG:
debug = True
else:
debug = False
alipay = AliPay(
appid=resources.get_alipay_app_id(),
app_notify_url=resources.get_alipay_notify_url(),
app_private_key_path=resources.get_viastelle_pri_key(),
alipay_public_key_path=resources.get_viastelle_pub_key(),
sign_type='RSA2',
debug=debug)
refund_result = alipay.api_alipay_trade_refund(
out_trade_no=alipay_transaction.out_trade_no,
trade_no=alipay_transaction.trade_no,
refund_amount=alipay_transaction.total_amount,
refund_reason='Customer asked')
if refund_result['code'] == '10000':
refund_status = 0
payment_status = 5
else:
refund_status = 1
payment_status = 6
try:
logger_info.info(refund_result)
refund_result['order_id'] = order_id
refund_result['status'] = refund_status
refund_result['alipay_refund_validation'] = True
serializer = AlipayRefundSerializer(data=refund_result)
if serializer.is_valid():
serializer.save()
else:
logger_info.info(serializer.errors)
payment.payment_status = payment_status
payment.save()
except Exception as e:
logger_info.error(str(e))
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4002_PAYMENT_IS_NOT_FOUND))
result.set_error(code.ERROR_4002_PAYMENT_IS_NOT_FOUND)
return Response(result.get_response(), result.get_code())
elif payment_type == 1 or payment_type == 3:
if payment_type == 1:
wechat_app_id = 'viastelle'
merchant_id = 'viastelle'
else:
wechat_app_id = 'viastelle'
merchant_id = 'viastelle'
transaction = WechatQueryTransaction.objects.get(order_id=order_id)
total_fee = transaction.total_fee
refund_data = {
'appid': wechat_app_id,
'mch_id': merchant_id,
'nonce_str':
payment_util.wechat_payment_str(transaction.order_id),
'transaction_id': transaction.transaction_id,
'out_trade_no': order_id,
'out_refund_no': transaction.transaction_id,
'total_fee': total_fee,
'refund_fee': total_fee
}
if payment_type == 1:
refund_data_xml = payment_util.get_payment_wechat_dict_to_xml(
refund_data)
else:
refund_data_xml = payment_util.get_payment_wechat_public_dict_to_xml(
refund_data)
logger_info.info(refund_data_xml)
# refund_data_signed = utils.calculate_signature(prepaid_object, api_key)
# prepaid_data = utils.dict_to_xml(prepaid_object, prepaid_signature)
api_cert_dir = '/home/nexttf/workspace/project_aries/config/keys'
if payment_type == 1:
api_cert = 'app_pay_apiclient_cert.pem'
api_key = 'app_pay_apiclient_key.pem'
else:
api_cert = 'public_pay_apiclient_cert.pem'
api_key = 'public_pay_apiclient_key.pem'
api_cert_file = os.path.join(api_cert_dir, api_cert)
api_key_file = os.path.join(api_cert_dir, api_key)
"""
verify=True, cert=(self.cert_file, self.key_file))
"""
headers = {'Content-Type': 'application/xml'}
response = requests.post(url=get_wechat_refund_url(),
headers=headers,
data=refund_data_xml,
verify=True,
cert=(api_cert_file, api_key_file))
logger_info.info(response.text)
try:
refund_result = xmltodict.parse(response.text)['xml']
logger_info.info(refund_result)
if refund_result['return_code'] == 'SUCCESS':
refund_status = 0
payment_status = 5
else:
refund_status = 1
payment_status = 6
validation = payment_util.get_payment_wechat_sign_validation(
refund_result)
refund_result['status'] = refund_status
refund_result['order_id'] = order_id
refund_result['wechat_refund_validation'] = validation
serializer = WechatRefundSerializer(data=refund_result)
if serializer.is_valid():
serializer.save()
else:
logger_info.info(serializer.errors)
payment.payment_status = payment_status
payment.save()
if refund_status == 1:
logger_error.error(code.ERROR_4003_PAYMENT_REFUND_FAIL)
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4003_PAYMENT_REFUND_FAIL))
result.set_error(code.ERROR_4003_PAYMENT_REFUND_FAIL)
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4002_PAYMENT_IS_NOT_FOUND))
result.set_error(code.ERROR_4002_PAYMENT_IS_NOT_FOUND)
return Response(result.get_response(), result.get_code())
return Response(result.get_response(), result.get_code())
def post(self, request):
request_data = request.data
if request_data.get('notification_order'):
notification_order = request_data.get('notification_order')
else:
notification_order = False
logger_info.info('Payment Initation : ' + str(request_data))
try:
order_id = request_data['order_id']
payment_data = request_data['payment_raw_data']
payment_type = request_data['payment_type']
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid')
return Response(result.get_response(), result.get_code())
if payment_type == 0:
request_data['payment_raw_data'] = json.dumps(payment_data)
elif payment_type == 2 or payment_type == 3:
request_data['payment_raw_data'] = json.dumps(payment_data)
logger_info.info('Raw_Data : ' + str(request_data['payment_raw_data']))
# Check if the payment exists
payment_count = Payment.objects.filter(order_id=order_id).count()
if payment_count != 0:
payment = Payment.objects.get(order_id=order_id)
if payment.payment_status == 0 or payment.payment_status == 1:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
return Response(result.get_response(), result.get_code())
# Set payment status
request_data['payment_status'] = self.PAYMENT_CREATED
payment_serializer = PaymentSerializer(data=request_data)
if payment_serializer.is_valid():
payment_serializer.save()
payment = Payment.objects.get(order_id=order_id)
else:
print(payment_serializer.errors)
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid')
return Response(result.get_response(), result.get_code())
# Set alipay client
alipay_client = AliPay(
debug=settings.DEBUG,
appid=resources.get_alipay_app_id(),
app_notify_url=urlmapper.get_url('ALIPAY_CALLBACK_URL'),
app_private_key_path=resources.get_viastelle_pri_key(),
alipay_public_key_path=resources.get_viastelle_pub_key(),
sign_type='RSA2'
)
if payment_type == self.ALIPAY_APP_PAYMENT and not notification_order:
# RSA signing check for sync
alipay_app_result = payment_data['alipay_trade_app_pay_response']
sign = payment_data['sign']
content = json.loads(payment_data['content'])
sign_result = alipay_client.verify(content, sign)
response_code = int(alipay_app_result['code'])
alipay_app_result['order_id'] = order_id
alipay_app_result['alipay_trade_app_pay_response'] = content
alipay_app_result['alipay_trade_app_pay_validation'] = sign_result
serializer = AlipayPaymentSerializer(data=alipay_app_result)
if serializer.is_valid():
serializer.save()
else:
logger_info.info(serializer.errors)
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid')
return Response(result.get_response(), result.get_code())
# Check validation
if response_code == 10000:
payment.payment_status = 1
payment.save()
else:
payment.payment_status = 4
payment.save()
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4004_PAYMENT_INTERFACE_FAILED))
result.set_error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED)
return Response(result.get_response(), result.get_code())
elif payment_type == self.ALIPAY_MOBILE_PAYMENT or notification_order:
# Mobile payment
logger_info.info('MOBILE_PAYMENT' + str(payment_data))
# Query to alipay server
query_response = alipay_client.api_alipay_trade_query(
out_trade_no=order_id,
)
logger_info.info('-----------------')
logger_info.info(str(query_response))
payment_count = AlipayPaymentTransaction.objects.filter(out_trade_no=order_id).count()
if payment_count <= 0:
# Query response to AlipayPaymentSerializer
logger_info.info(type(payment_data))
alipay_payment = {
'alipay_trade_validation': False,
'code': query_response['code'],
'msg': query_response['msg'],
'app_id': payment_data['app_id'],
'charset': payment_data['charset'],
'out_trade_no': payment_data['out_trade_no'],
'seller_id': payment_data['seller_id'],
'timestamp': query_response['send_pay_date'],
'total_amount': payment_data['total_amount'],
'trade_no': payment_data['trade_no']
}
serializer = AlipayPaymentSerializer(data=alipay_payment)
if serializer.is_valid():
serializer.save()
else:
logger_info.info(serializer.errors)
query_count = AlipayQueryTransaction.objects.filter(order_id=order_id).count()
if query_count <= 0:
serializer = AlipayQuerySerializer(data=query_response)
query_response['order_id'] = order_id
if serializer.is_valid():
serializer.save()
else:
logger_info.info(serializer.errors)
logger_info.info('Before code == 10000')
if query_response['code'] == '10000':
payment.payment_status = 1
payment.save()
else:
payment.payment_status = 4
payment.save()
logger_error.error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4004_PAYMENT_INTERFACE_FAILED))
result.set_error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED)
return Response(result.get_response(), result.get_code())
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 parsing
try:
request_data = request.data
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())
# Set alipay client
alipay_client = AliPay(
debug=settings.DEBUG,
appid=resources.get_alipay_app_id(),
app_notify_url=urlmapper.get_url('ALIPAY_CALLBACK_URL'),
app_private_key_path=resources.get_viastelle_pri_key(),
alipay_public_key_path=resources.get_viastelle_pub_key(),
sign_type='RSA2'
)
# Notification verification from ALIPAY
noti_origin_data = json.dumps(request_data)
noti_data = json.loads(noti_origin_data)
sign = noti_data.pop('sign')
sign_type = noti_data['sign_type']
trade_status = noti_data['trade_status']
verify_result = alipay_client.verify(noti_data, sign)
logger_info.info('[notification_data]:' + noti_origin_data)
logger_info.info(verify_result)
if not verify_result:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(code.ERROR_4004_PAYMENT_INTERFACE_FAILED))
result.set_error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED)
return Response(result.get_response(), result.get_code())
# Check the order exists
try:
order_id = noti_data['out_trade_no']
noti_data['order_id'] = order_id
noti_data['sign'] = sign
noti_data['sign_type'] = sign_type
noti_data['alipay_notification_validation'] = verify_result
order_count = Order.objects.filter(order_id=order_id).count()
purchase_order_count = PurchaseOrder.objects.filter(order_id=order_id).count()
if order_count == 0 and purchase_order_count == 1 and trade_status == 'TRADE_SUCCESS':
# Order has not created
purchase_order = PurchaseOrder.objects.get(order_id=order_id)
open_id = purchase_order.open_id
url = urlmapper.get_url('USER_PAYMENT_TOKEN')
payload = {
'open_id': purchase_order.open_id
}
response = requests.post(url, json=payload)
if response.status_code == 200:
response_json = response.json()
access_token = response_json['access_token']
else:
return Response(result.get_response, result.get_code())
url = urlmapper.get_url('ORDER')
headers = {
'open-id': open_id,
'authorization': 'bearer ' + access_token
}
payload = {
'order_id': order_id,
'payment_type': self.ALIPAY_MOBILE_PAYMENT,
'payment_data': noti_data,
'alipay_notification_order': True
}
response = requests.post(url, headers=headers, json=payload)
logger_info.info(response.text)
notification_count = AlipayNotification.objects.filter(
order_id=order_id
).count()
if notification_count == 0:
serializer = AlipayNotificationSerializer(data=noti_data)
else:
notification_instance = AlipayNotification.objects.get(order_id=order_id)
serializer = AlipayNotificationSerializer(notification_instance, data=noti_data, partial=True)
if serializer.is_valid():
serializer.save()
else:
logger_info.info(serializer.errors)
except Exception as e:
logger_info.info(str(e))
return Response(result.get_response(), result.get_code())
def put(self, request, order_id):
logger_info.info(order_id)
request_data = request.data
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
# Request data parsing
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())
# Get purchase order instance
try:
order = Order.objects.get(open_id=open_id, order_id=order_id)
purchase_order = PurchaseOrder.objects.get(open_id=open_id, order_id=order.order_id)
except Exception as e:
logger_error.error(str(e))
error_code = code.ERROR_3002_PURCHASE_ORDER_NOT_FOUND
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
# Check order status to edit
if order.order_status != 0:
error_code = code.ERROR_3009_ORDER_EDIT_NOT_AVAILABLE
logger_error.error(error_code)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
# Applying changed items to purchase order information
try:
# Check delivery schedule
original_schedule = purchase_order.delivery_schedule
new_schedule = request_data['delivery_schedule']
if original_schedule != request_data['delivery_schedule']:
hub_id = purchase_order.hub_id
delivery_date = str(purchase_order.delivery_date)[:10]
method = purchase_order.shipping_method
if purchase_order.delivery_on_site:
method = 1
query_str = '/' + str(hub_id) + '/' + delivery_date + '/' + str(new_schedule) + '/' + str(method)
url = urlmapper.get_url('TIMETABLE_LIST') + query_str
response = requests.get(url)
response_json = response.json()
if response.status_code != code.ARIES_200_SUCCESS:
api_result = response.json()
result = ResultResponse(api_result['code'],
api_result['message'])
result.set_error(api_result['error_code'])
return Response(result.get_response(), result.get_code())
if response_json['availability']:
start_time = response_json['delivery_start_time']
end_time = response_json['delivery_end_time']
request_data['delivery_start_time'] = start_time
request_data['delivery_end_time'] = end_time
if start_time[1:2] == '0':
start_time_prefix = start_time[:2]
start_time_postfix = start_time[2:]
else:
start_time_prefix = start_time[:1]
start_time_postfix = start_time[1:]
if end_time[1:2] == '0':
end_time_prefix = end_time[:2]
end_time_postfix = end_time[2:]
else:
end_time_prefix = end_time[:1]
end_time_postfix = end_time[1:]
post_str = start_time_prefix + start_time_postfix + '-' + end_time_prefix + end_time_postfix
order.delivery_time = order.delivery_time[:12] + post_str
order.delivery_schedule = new_schedule
order.save()
else:
error_code = code.ERROR_3007_DELIVERY_SCHEDULE_INVALID
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
get_msg(error_code))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
# Check Address information
old_address_id = purchase_order.delivery_address_id
new_address_id = request_data['delivery_address_id']
if old_address_id != new_address_id:
# Check if hub_id was changed
product_list = json.loads(purchase_order.product_list)
payload = {'product_list': product_list, 'delivery_schedule': new_schedule}
response = requests.post(urlmapper.get_url('PRODUCT_VALIDATION'), json=payload)
if response.status_code == code.ARIES_200_SUCCESS:
response_json = response.json()
else:
logger_error.error(response.text)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
code.ERROR_9000_INTERNAL_API_CALL_FAILED)
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
return Response(result.get_response(), result.get_code())
# Product validation check
product_count = response_json['product_count']
if product_count != len(product_list):
logger_error.error(code.ERROR_3010_DELIVERY_CHANGE_NOT_ALLOWED)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
code.ERROR_3010_DELIVERY_CHANGE_NOT_ALLOWED)
result.set_error(code.ERROR_3010_DELIVERY_CHANGE_NOT_ALLOWED)
return Response(result.get_response(), result.get_code())
# If product is valid, change product stock and more address change business logic
# TBD
headers = {'open-id': str(open_id), 'authorization': 'bearer ' + access_token}
response = requests.get(urlmapper.get_url('PRODUCT_ADDRESS_DETAIL') + '/' +
str(new_address_id), headers=headers)
if response.status_code == code.ARIES_200_SUCCESS:
response_json = response.json()
else:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
code.ERROR_9000_INTERNAL_API_CALL_FAILED)
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
return Response(result.get_response(), result.get_code())
# Register address to database
address = response_json['user_address']
order.delivery_address = address['name'] + ' ' + address['detail']
order.save()
request_data['delivery_address_id'] = new_address_id
order_serializer = PurchaseOrderSerializer(purchase_order, data=request_data, partial=True)
if order_serializer.is_valid():
order_serializer.save()
purchase_order = PurchaseOrder.objects.get(id=order_serializer.data['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']
order_serializer = UpcomingOrderSerializer(order)
order_data = order_serializer.data
order_start_date = datetime.strptime((str(order.order_start_date)[:-10]), '%Y-%m-%d %H:%M')
order_data['order_start_date'] = order_start_date.strftime('%Y-%m-%d %I:%M %p')
order_data['order_status_history'] = json.loads(order_data['order_status_history'])
order_data['purchase_order'] = purchase_order_data
order_data['order_cancel_date'] = ''
# Get Timetable
order_status = order_data['order_status']
if order_status == 0:
hub_id = purchase_order.hub_id
sales_time = product_util.get_sales_time_to_str(purchase_order.sales_time)
response = requests.get(urlmapper.get_time_table_url(hub_id, sales_time))
response_json = response.json()
order_data['timetable'] = response_json['timetable']
else:
order_data['timetable'] = json.loads('[]')
result.set('upcoming_order', order_data)
else:
logger_info.info(order_serializer.errors)
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid')
return Response(result.get_response(), result.get_code())
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_login_info(self):
# QQ Mobile web Login
login_sns_open_id = self.login_data['login_sns_open_id']
payload = {
'grant_type': 'authorization_code',
'client_id': '1106290901',
'client_secret': 'WbcNyj80WeBvgoSs',
'code': login_sns_open_id,
'redirect_uri': 'https://api.viastelle.com/users/signin/callback'
}
response = requests.get(resources.QQ_ACCESS_TOKEN_URL, params=payload)
logger_info.info(response.text)
res_text = response.text
if 'access_token' in res_text:
res_json = json.loads(json.dumps(parse_qs(res_text)))
qq_access_token = res_json['access_token'][0]
qq_exprires_in = res_json['expires_in'][0]
qq_refresh_token = res_json['refresh_token'][0]
payload = {'access_token': qq_access_token}
response = requests.get(resources.QQ_OPEN_ID_URL, params=payload)
res_text = response.text
logger_info.info(res_text)
split_res = res_text.split(' ')
json_result = json.loads(split_res[1])
response_openid = json_result['openid']
login_sns_access_token = response_openid
login_sns_open_id = login_sns_access_token
try:
login_info = UserLoginInfo.objects.filter(
login_sns_open_id=login_sns_open_id)[0]
except Exception as e:
print(e)
qq_login_data = {
'login_key': login_sns_access_token,
'login_value': '',
'login_sns_open_id': login_sns_access_token,
'login_sns_access_token': qq_access_token,
'login_sns_refresh_token': qq_refresh_token,
}
sign_up_manager = SignUpManager()
result = sign_up_manager.sign_up(QQ_MOBILE, qq_login_data)
else:
login_instance = UserLoginInfo.objects.get(
login_sns_open_id=login_sns_open_id)
login_instance.login_sns_access_token = login_sns_access_token
login_instance.login_sns_refresh_token = qq_refresh_token
login_instance.save()
result = (login_info, login_sns_open_id, False)
return result
else:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL))
result.set_error(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)
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 get_login_info(self):
# Wechat Login
login_sns_open_id = self.login_data['login_sns_open_id']
login_type = self.login_data['login_type']
if login_type == WECHAT_APPLICATION:
# WeChat app login
payload = {
'appid': 'wx87010cb61b99206d',
'secret': '21b9cf8d51b704fd244f40b351d7876e',
'code': login_sns_open_id,
'grant_type': 'authorization_code'
}
else:
# WeChat public account login
payload = {
'appid': 'wx41b86399fee7a2ec',
'secret': '1b3d5dce9860be7e4fc04847df6a6177',
'code': login_sns_open_id,
'grant_type': 'authorization_code'
}
response = requests.get(resources.WECHAT_ACCESS_TOKEN_URL,
params=payload)
response_json = response.json()
logger_info.info(response.text)
if response_json.get('unionid'):
login_sns_open_id = response_json['unionid']
try:
login_info = UserLoginInfo.objects.filter(
login_sns_open_id=login_sns_open_id)[0]
except Exception as e:
print(e)
wechat_login_data = {
'login_key': response_json['openid'],
'login_value': '',
'login_sns_open_id': login_sns_open_id,
'login_sns_access_token': response_json['access_token'],
'login_sns_refresh_token': response_json['refresh_token']
}
sign_up_manager = SignUpManager()
result = sign_up_manager.sign_up(WECHAT_APPLICATION,
wechat_login_data)
else:
login_instance = UserLoginInfo.objects.get(
login_sns_open_id=login_sns_open_id)
login_instance.login_sns_access_token = response_json[
'access_token']
login_instance.login_sns_refresh_token = response_json[
'refresh_token']
login_instance.save()
result = (login_info, login_sns_open_id, False)
return result
else:
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL))
result.set_error(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)
logger_error.error(
code_msg.get_msg(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL))
return Response(result.get_response(), result.get_code())
def post(self, request):
logger_info.info(request.data)
access_token = ''
open_id = ''
try:
access_token = str(
request.META['HTTP_AUTHORIZATION']).split(' ')[1]
open_id = request.META['HTTP_OPEN_ID']
user_count = User.objects.filter(
open_id=open_id, access_token=access_token).count()
if user_count == 1:
user_info = True
else:
user_info = False
except Exception as e:
logger_info.info(str(e))
user_info = False
try:
mdn = request.data['mdn']
verification_code = request.data['verification_code']
today = datetime.datetime.today()
sms_auth_count = SmsAuthHistory.objects.filter(
date=today, target_mdn=mdn).count()
if sms_auth_count == 0:
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
"Request data validation fail")
return Response(result.get_response(), result.get_code())
sms_auth = SmsAuthHistory.objects.filter(
date=today, target_mdn=mdn).latest('id')
system_code = sms_auth.verification_code
if system_code == verification_code:
sms_auth.verification_count += 1
sms_auth.has_verified = True
else:
sms_auth.verification_count += 1
sms_auth.save()
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
"Request data validation fail")
return Response(result.get_response(), result.get_code())
cache_data = cache.get(mdn)
if cache_data is None:
logger_info.info('verify code is not found')
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
"Verify code is not found")
return Response(result.get_response(), result.get_code())
if verification_code == cache_data:
# Verification success
cache.set(mdn, 'complete', 300)
# Update user information
logger_info.info(user_info)
if user_info:
try:
# Original user information
original_user = User.objects.get(open_id=open_id,
access_token=access_token)
# Check if already verification member
user_login_count = UserLoginInfo.objects.filter(
login_key=mdn).count()
before_mdn_user_count = User.objects.filter(
mdn=mdn).count()
if user_login_count == 0 and before_mdn_user_count == 1:
before_user = User.objects.get(mdn=mdn)
if before_user.open_id == original_user.open_id:
original_user.mdn_verification = True
else:
# 20180130 check
original_user.mdn = mdn
before_user.mdn = ''
before_user.mdn_verification = False
original_user.save()
before_user.save()
elif user_login_count == 1:
user_login_info = UserLoginInfo.objects.get(
login_key=mdn)
user = user_login_info.user
if user.open_id != original_user.open_id:
# Other mobile member case
if "010" in user.name:
user.name = user.open_id[:6]
user.mdn = ''
user.mdn_verification = False
user.save()
new_mdn = 'dormant_' + mdn + '_' + (
'%04d' % random.randint(1, 9999))
user_login_info.login_key = new_mdn
user_login_info.save()
# Send push service
sender = SmsIdSender(mdn, new_mdn)
sender.start()
# Original user information save
if "010" in original_user.name:
original_user.name = mdn
original_user.mdn = mdn
original_user.mdn_verification = True
original_user.save()
login_count = UserLoginInfo.objects.filter(
user=original_user, login_type=0).count()
if login_count == 1:
user_login_origin = UserLoginInfo.objects.get(
user=original_user, login_type=0)
user_login_origin.login_key = mdn
user_login_origin.save()
# Original user login information delete
payload = {
'user_open_id': user.open_id,
'user_account': mdn
}
response = requests.delete(
urlmapper.get_url('PLATFORM_SERVER'),
json=payload)
logger_info.info(response.text)
else:
# login info is same
user_login_info.login_key = mdn
user_login_info.save()
original_user.mdn = mdn
original_user.mdn_verification = True
original_user.save()
else:
# Check if parent type
if original_user.parent_type == 0:
original_user_mdn = original_user.mdn
original_login_info = UserLoginInfo.objects.get(
user=original_user,
login_key=original_user_mdn)
original_login_info.login_key = mdn
original_login_info.save()
# SNS member
original_user.mdn = mdn
original_user.mdn_verification = True
original_user.save()
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
code_msg.get_msg(
code.ERROR_1003_SMS_VERIFICATION_FAILURE))
result.set_error(code.ERROR_1003_SMS_VERIFICATION_FAILURE)
return Response(result.get_response(), result.get_code())
result = ResultResponse(code.ARIES_200_SUCCESS,
"SMS verification success")
else:
logger_info.info('Verification code is different')
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
"Verification code is different")
return Response(result.get_response(), result.get_code())
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
try:
trade_type = request_data['trade_type']
product_list = request_data['product_list']
validate_str = request_data['validate_str']
if validate_str != 'GoDbAcKeNdS':
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
get_msg(code.ARIES_401_UNAUTHORIZED))
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
get_msg(code.ARIES_401_UNAUTHORIZED))
return Response(result.get_response(), result.get_code())
try:
sales_status = 1
for product_item in product_list:
product_id = product_item['product_id']
quantity = product_item['quantity']
product = Product.objects.get(id=product_id)
menu = product.menu
hub = product.hub
product_stock = HubStock.objects.get(hub=hub, menu=menu)
stock_count = product_stock.stock
sold_count = product_stock.sold
if trade_type == 0:
stock_count -= quantity
sold_count += quantity
else:
stock_count += quantity
sold_count -= quantity
if sold_count <= 0:
sold_count = 0
if stock_count <= 0:
stock_count = 0
products = Product.objects.filter(hub=hub,
menu=menu,
status__lte=sales_status)
for sold_product in products:
sold_product_instance = Product.objects.get(
id=sold_product.id)
sold_product_instance.status = 0
sold_product_instance.save()
if stock_count >= 1:
product_status = product.status
if product_status == 0:
product.status = sales_status
product.save()
product_stock.stock = stock_count
product_stock.sold = sold_count
product_stock.save()
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
'Error : ' + str(e))
return Response(result.get_response(), result.get_code())
def get(self, request, hub_id, date, table_id, shipping_type):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
target_db = 'default'
if request.META.get('HTTP_ACCEPT_LANGUAGE'):
accept_lang = request.META['HTTP_ACCEPT_LANGUAGE']
if 'zh' in accept_lang:
target_db = 'aries_cn'
try:
shipping_methods = ShippingMethod.objects.using(target_db).filter(hub_id=hub_id)
shipping_method_list = ShippingMethodListSerializer(shipping_methods, many=True).data
result.set('shipping_detail', shipping_method_list)
except ShippingMethod.DoesNotExist:
print("ShippingMethod is not defined for hub id: {0}".format(hub_id))
error_code = code.ERROR_3012_NOT_SUPPORT_DELIVERY_METHOD
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code))
result.set_error(code.ERROR_3012_NOT_SUPPORT_DELIVERY_METHOD)
return Response(result.get_response(), result.get_code())
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e))
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
return Response(result.get_response(), result.get_code())
# Default value
dlv_schedules = ''
try:
# print(str(date))
today = datetime.datetime.strptime(date, '%Y-%m-%d').date()
next_working_day = today + datetime.timedelta(days=30)
dlv_schedules = DeliverySchedule.objects.filter(working_day__range=[today, next_working_day])
shipping_avail = ShippingAvailability.objects.get(ds_id=dlv_schedules[0], hub_id=hub_id)
time_slots_avail = json.loads(shipping_avail.shipping_availability_table)
for target_slot in time_slots_avail:
if str(target_slot['index']) == table_id:
for target_slot_avail in target_slot['shipping']:
if str(target_slot_avail['shipping_type']) == shipping_type:
result.set('availability', target_slot_avail['available'])
result.set('delivery_start_time', target_slot['starttime'])
result.set('delivery_end_time', target_slot['endtime'])
return Response(result.get_response(), result.get_code())
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Invalid timetable index or shipping type')
result.set_error(code.ERROR_3007_DELIVERY_SCHEDULE_INVALID)
except DeliverySchedule.DoesNotExist:
print("No delivery schedule is found for date at {0},hub {1}".format(str(date), str(hub_id)))
error_code = code.ERROR_3011_NO_AVAILABLE_DELIVERY_SCHEDULE
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
except ShippingAvailability.DoesNotExist:
print("No shipping schedule is found for ds_id-{0},hub {1}".format(str(dlv_schedules.id), str(hub_id)))
error_code = code.ERROR_3011_NO_AVAILABLE_DELIVERY_SCHEDULE
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code))
result.set_error(error_code)
return Response(result.get_response(), result.get_code())
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e))
result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED)
return Response(result.get_response(), result.get_code())
