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):
request_data = request.data
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
logger_info.info(request_data)
# Get access token
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1]
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())
# Request data parsing
try:
product_id = request_data['product_id']
order_id = request_data['order_id']
headers = {'open-id': open_id, 'AUTHORIZATION': 'bearer ' + access_token}
response = requests.get(urlmapper.get_url('PRODUCT') + '/' + str(product_id), headers=headers)
response_json = response.json()
product = response_json['product']
menu = product['menu']
menu_id = menu['id']
if request_data['menu_rate'] == 0:
request_data['menu_rate'] = 5
request_data['open_id'] = open_id
request_data['product_id'] = product_id
request_data['menu'] = menu_id
request_data['has_reviewed'] = True
# Check selective review object
comment = request_data['comment']
if len(comment) <= 1:
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())
# Check if review exists
try:
review_count = CustomerReview.objects.filter(
open_id=open_id, product_id=product_id, order_id=order_id
).count()
# Not exists review
if review_count <= 0:
serializer = CustomerReviewSerializer(data=request_data)
if serializer.is_valid():
serializer.save()
review_data = serializer.data
if open_id == review_data['open_id']:
review_data['editable'] = True
else:
review_data['editable'] = False
del review_data['created_date']
del review_data['menu']
del review_data['open_id']
# If review article saved, send Review Detail
result.set('review_detail', review_data)
# Statics information apply
payload = {'menu_id': menu_id, 'menu_rate': request_data['menu_rate'],
'has_reviewed': False, 'menu_prev_rate': 0.0}
statics_result = requests.post(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())
else:
review = CustomerReview.objects.get(open_id=open_id, product_id=product_id, order_id=order_id)
prev_rate = review.menu_rate
serializer = CustomerReviewSerializer(review, data=request_data, partial=True)
if serializer.is_valid():
serializer.save()
review_data = serializer.data
if open_id == review_data['open_id']:
review_data['editable'] = True
else:
review_data['editable'] = False
del review_data['created_date']
del review_data['menu']
del review_data['open_id']
result.set('review_detail', review_data)
# Statics information apply
payload = {'menu_id': menu_id, 'menu_rate': request_data['menu_rate'],
'has_reviewed': True, 'menu_prev_rate': prev_rate}
statics_result = requests.post(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())
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 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):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
self.logger_info.info(request_data)
dada_manager = DadaManager(self.logger_info, self.logger_error)
try:
# request data validation
dada_util.dada_new_order_validation(request_data)
order_id = request_data['order_id']
receiver_address = request_data['receiver_address']
receiver_lat = request_data['receiver_lat']
receiver_lng = request_data['receiver_lng']
# Make a new order
dada_manager.add_order(request_data)
# Make a new order detail
dada_manager.add_order_detail(order_id, receiver_address,
receiver_lat, receiver_lng)
# Read dada order detail
dada_order_data = dada_manager.read_order_detail(order_id)
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
except AuthInfoError:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Authentication error')
except BusinessLogicError as instance:
message, err_code, data_set = instance.args
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
message, err_code)
result.set_map(data_set)
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result.set('shipping_order_detail', dada_order_data)
return Response(result.get_response(), result.get_code())
def get(self, request):
auth_info = header_parser.parse_authentication(request)
language_info = header_parser.parse_language(request.META)
event_manager = EventManager(self.logger_info, self.logger_error)
try:
event = event_manager.get_event_status(auth_info, None,
language_info[0])
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('event', event['event'])
result.set('event_reward', event['event_reward'])
result.set('event_info', event['event_info'])
return Response(result.get_response(), result.get_code())
def get(self, request, order_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
auth_info = header_parser.parse_auth_info(request)
self.logger_info.info(auth_info.access_token)
dada_manager = DadaManager(self.logger_info, self.logger_error)
try:
# Read dada detail
dada_order_data = dada_manager.read_order_detail(order_id)
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
except AuthInfoError:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Authentication error')
except BusinessLogicError as instance:
message, err_code, data_set = instance.args
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
message, err_code)
result.set_map(data_set)
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result.set('shipping_order_detail', dada_order_data)
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
self.logger_info.info(request_data)
dada_manager = DadaManager(self.logger_info, self.logger_error)
try:
# request data validation
dada_util.dada_order_add_after_query_validation(request_data)
# Make a new order
query_result = dada_manager.order_add_after_query(request_data)
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
except AuthInfoError:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Authentication error')
except BusinessLogicError as instance:
message, err_code, data_set = instance.args
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
message, err_code)
result.set_map(data_set)
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result.set_map(query_result)
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, receipt_id):
request_data = request.data
self.logger_info.info('[UserReceiptDetail][put][' + str(request_data) +
']')
auth_info = header_parser.parse_auth_info(request)
lang_info = parse_language_v2(request.META)
try:
check_auth_info_v2(auth_info.open_id, auth_info.access_token)
receipt_util.request_validation(auth_info.open_id, request_data)
receipt_manager = ReceiptManager(self.logger_info,
self.logger_error)
receipt_list = receipt_manager.update_user_receipt(
auth_info.open_id, int(receipt_id), request_data,
lang_info.cn_header)
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
except AuthInfoError:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Authentication error')
except BusinessLogicError as instance:
message, err_code, data_set = instance.args
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
message, err_code)
result.set_map(data_set)
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('user_receipts', receipt_list)
return Response(result.get_response(), result.get_code())
def post(self, request):
request_data = request.data
target_db = 'default'
cn_header = False
if request.META.get('HTTP_ACCEPT_LANGUAGE'):
accept_lang = request.META['HTTP_ACCEPT_LANGUAGE']
if 'zh' in accept_lang:
target_db = 'aries_cn'
cn_header = True
if cn_header:
self.SUCCESS = self.SUCCESS_CN
result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS)
# 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)
serial_number = request_data['serial_number']
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid(Token or Open id)')
return Response(result.get_response(), result.get_code())
# Validation check
try:
payload = {'open_id': open_id, 'access_token': access_token}
url = urlmapper.get_url('USER_VALIDATION')
response = requests.post(url, json=payload)
if response.status_code != code.ARIES_200_SUCCESS:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Authorization error')
return Response(result.get_response(), result.get_code())
promotion_coupon_count = EventCoupon.objects.filter(
serial_number=serial_number).count()
if promotion_coupon_count <= 0:
if cn_header:
self.COUPON_NOT_EXISTS = self.COUPON_NOT_EXISTS_CN
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
self.COUPON_NOT_EXISTS)
return Response(result.get_response(), result.get_code())
promotion_coupon = EventCoupon.objects.get(
serial_number=serial_number)
event_type = promotion_coupon.event_type
if promotion_coupon.name == open_id:
if cn_header:
self.SELF_ISSUED = self.SELF_ISSUED_CN
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
self.SELF_ISSUED)
return Response(result.get_response(), result.get_code())
coupon_code = promotion_coupon.coupon_code
customer_coupon_count = CustomerCoupon.objects.filter(
open_id=open_id, coupon_code=coupon_code).count()
if customer_coupon_count >= 1 and (event_type == 0
or event_type == 2):
if cn_header:
self.COUPON_KIND_LIMITATION = self.COUPON_KIND_LIMITATION_CN
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
self.COUPON_KIND_LIMITATION)
return Response(result.get_response(), result.get_code())
if promotion_coupon.issued and event_type != 2:
if cn_header:
self.ALREADY_ISSUED = self.ALREADY_ISSUED_CN
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
self.ALREADY_ISSUED)
return Response(result.get_response(), result.get_code())
if event_type == 2 and promotion_coupon.issued_limitation != 0 \
and promotion_coupon.issued_count+1 > promotion_coupon.issued_limitation:
if cn_header:
self.COUPON_COUNT_LIMITATION = self.COUPON_COUNT_LIMITATION_CN
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
self.COUPON_COUNT_LIMITATION)
return Response(result.get_response(), result.get_code())
if not promotion_coupon.has_coupon_pack:
today = date.today()
coupon_count = Coupon.objects.using(target_db).filter(
id=promotion_coupon.coupon_id,
period_start_date__lte=today,
period_end_date__gte=today).count()
if coupon_count <= 0:
if cn_header:
self.PROMOTION_EXPIRED = self.PROMOTION_EXPIRED_CN
result = ResultResponse(
code.ARIES_500_INTERNAL_SERVER_ERROR,
self.PROMOTION_EXPIRED)
return Response(result.get_response(), result.get_code())
except Exception as e:
print(e)
logger_error.error(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
return Response(result.get_response(), result.get_code())
# Coupon create
try:
coupon_id_list = list()
today = date.today()
if promotion_coupon.has_coupon_pack:
coupon_pack_list = json.loads(promotion_coupon.coupon_pack)
for coupon_item in coupon_pack_list:
coupon = Coupon.objects.using(target_db).get(
id=coupon_item['id'])
coupon_dates = product_util.get_coupon_date(
coupon.period_type, coupon.period_day,
coupon.period_start_date, coupon.period_end_date)
for index in range(coupon_item['quantity']):
customer_coupon = CustomerCoupon.objects.create(
coupon=coupon,
coupon_code=coupon_code,
open_id=open_id,
issue_date=today,
start_date=coupon_dates[0],
end_date=coupon_dates[1],
sender_id=promotion_coupon.name,
status=0)
coupon_id_list.append(customer_coupon.id)
else:
coupon = Coupon.objects.using(target_db).get(
id=promotion_coupon.coupon_id)
coupon_dates = product_util.get_coupon_date(
coupon.period_type, coupon.period_day,
coupon.period_start_date, coupon.period_end_date)
created_coupon_count = promotion_coupon.coupon_count
for index in range(created_coupon_count):
customer_coupon = CustomerCoupon.objects.create(
coupon=coupon,
coupon_code=coupon_code,
open_id=open_id,
issue_date=today,
start_date=coupon_dates[0],
end_date=coupon_dates[1],
sender_id=promotion_coupon.name,
status=0)
coupon_id_list.append(customer_coupon.id)
coupon_count = len(coupon_id_list)
if promotion_coupon.issued_limitation != 0:
promotion_coupon.issued_count = F('issued_count') + 1
promotion_coupon.issued = True
promotion_coupon.issued_date = today
promotion_coupon.issued_user_open_id = open_id
promotion_coupon.issued_customer_coupon_id = str(coupon_id_list)
promotion_coupon.save()
# Coupon count up
headers = {
'open-id': open_id,
'authorization': 'bearer ' + access_token
}
url = urlmapper.get_url('USER_NOTIFICATION') + '/coupon/0/' + str(
coupon_count)
response = requests.get(url, headers=headers)
logger_info.info(response.text)
# After coupon issued, response current coupon list
default_page = 1
default_limit = 100
expired_date = 7
coupon_manager = CouponManagerV3(logger_info, logger_error)
coupon_list = coupon_manager.get_coupon_list(
open_id, access_token, target_db, default_page, default_limit,
expired_date)
result.set('coupon_id', coupon_id_list)
result.set_map(coupon_list)
return Response(result.get_response(), result.get_code())
except Exception as e:
print(e)
logger_error.error(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(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 get(self, request, product_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
lang_info = parse_language_v2(request.META)
target_db = lang_info.target_db
os_type = lang_info.os_type
cn_header = lang_info.cn_header
product_queryset = Product.objects.filter(id=product_id, type__lte=10)
product_count = product_queryset.count()
if product_count < 1:
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Product not found')
return Response(result.get_response(), status=result.get_code())
# Create manager
product_manager = ProductManagerV3(logger_info, logger_error)
menu_manager = MenuManagerV2(logger_info, logger_error)
review_manager = ReviewManager(logger_info, logger_error)
# Get product information
product = product_manager.get_product_data(product_id)
hub_id = product['hub']
# Parsing menu and restaurant data
menu_manager.get_menu_data(product, target_db, cn_header)
result.set('product', product)
# Recommend product information
product_list = product_manager.get_recommend_product(hub_id)
for product_obj in product_list:
menu_manager.get_menu_data(product_obj, target_db, cn_header)
result.set('products', product_list)
# Time bomb information
time_bomb_manager = TimeBombManager(self.logger_info, self.logger_error)
time_bomb_id = time_bomb_manager.get_time_bomb_now(hub_id, os_type, has_after=False)
if time_bomb_id is not None:
discount_map = product_manager.get_all_discount_info(time_bomb_id, cn_header)
if product['id'] in discount_map:
discount_info = discount_map[product['id']]
add_discount_information(product, discount_info)
# Expert review
expert_review = review_manager.get_expert_review(target_db, product['menu']['id'])
result.set('expert_review', expert_review)
# Review articles
# reviews = review_manager.get_product_review(language_info[2], product_id)
result.set('total_count', 0)
result.set('page_size', 0)
result.set('customer_reviews', [])
return Response(result.get_response(), status=result.get_code())
def post(self, request):
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 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 get(self, request):
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]
logger_info.info(open_id + ':' + access_token)
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data invalid(Token or Open id)')
return Response(result.get_response(), result.get_code())
# Get usable coupon count and upcoming order count
try:
today = date.today()
coupon_count = CustomerCoupon.objects.filter(
open_id=open_id, status=0, end_date__gte=today).count()
upcoming_order_count = Order.objects.filter(
open_id=open_id, order_status__lt=3).count()
result.set('coupon_count', coupon_count)
result.set('upcoming_order_count', upcoming_order_count)
return Response(result.get_response(), result.get_code())
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
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):
request_data = request.data
logger_info.info(request_data)
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
# Operation check
try:
access_token = str(
request.META['HTTP_AUTHORIZATION']).split(' ')[1]
url = urlmapper.get_url('ADMIN_VALIDATE')
payload = {'access_token': access_token}
response = requests.post(url, json=payload)
if response.status_code != code.ARIES_200_SUCCESS:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Token or user not found')
return Response(result.get_response(), result.get_code())
except Exception as e:
print(e)
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Error : ' + str(e))
return Response(result.get_response(), result.get_code())
try:
open_id = request_data['open_id']
news_type = request_data['type']
title = request_data['title']
title_cn = request_data['title_cn']
content = request_data['content']
content_cn = request_data['content_cn']
detail = request_data['detail']
detail_cn = request_data['detail_cn']
user = User.objects.get(open_id=open_id)
UserNews.objects.create(user=user,
type=news_type,
title=title,
title_cn=title_cn,
content=content,
content_cn=content_cn,
has_read=False,
detail=detail,
detail_cn=detail_cn)
user_notify_info = UserNotifyInfo.objects.get(user=user)
user_notify_info.has_news = True
user_notify_info.news_count = F('news_count') + 1
user_notify_info.save()
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Error : ' + str(e))
return Response(result.get_response(), result.get_code())
return Response(result.get_response(), result.get_code())
def post(self, request):
request_data = request.data
self.logger_info.info(request_data)
try:
# Request data validation
dada_util.dada_cancel_order_validation(request_data)
# Request data parsing
order_id = request_data['order_id']
cancel_reason_id = request_data['cancel_reason_id']
# Cancel order request
dada_manager = DadaManager(self.logger_info, self.logger_error)
cancel_result = dada_manager.cancel_order(order_id,
cancel_reason_id)
# Read dada detail
dada_order_data = dada_manager.update_order_detail(order_id)
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
except AuthInfoError:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Authentication error')
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('deduct_fee', cancel_result['deduct_fee'])
result.set('shipping_order_detail', dada_order_data)
return Response(result.get_response(), result.get_code())
def get(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
try:
access_token = str(
request.META['HTTP_AUTHORIZATION']).split(' ')[1]
logger_info.info(access_token)
user_manager = UserManager()
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Token or user not found')
return Response(result.get_response(), result.get_code())
try:
user_list = user_manager.get_user_list(request)
result.set('total_count', len(user_list))
result.set('search_items', user_list)
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Bad request')
return Response(result.get_response(), result.get_code())
def post(self, request):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
request_data = request.data
self.logger_info.info(request_data)
dada_manager = DadaManager(self.logger_info, self.logger_error)
try:
# request data validation
dada_util.dada_query_validation(request_data)
# Make a new order
query_result = dada_manager.order_location_query(request_data)
# Select result of query
selected_result = {
'orderId': query_result['orderId'],
'statusCode': query_result['statusCode'],
'transporterName': query_result['transporterName'],
'transporterPhone': query_result['transporterPhone'],
'transporterLng': query_result['transporterLng'],
'transporterLat': query_result['transporterLat'],
'createTime': query_result['createTime'],
'acceptTime': query_result['acceptTime'],
'fetchTime': query_result['fetchTime'],
'finishTime': query_result['finishTime'],
'cancelTime': query_result['cancelTime']
}
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
except AuthInfoError:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Authentication error')
except BusinessLogicError as instance:
message, err_code, data_set = instance.args
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
message, err_code)
result.set_map(data_set)
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result.set_map(selected_result)
return Response(result.get_response(), result.get_code())
def post(self, request):
request_data = request.data
logger_info.info(request_data)
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
# Operation check
try:
access_token = request_data['access_token']
url = urlmapper.get_url('ADMIN_VALIDATE')
payload = {'access_token': access_token}
response = requests.post(url, json=payload)
if response.status_code != code.ARIES_200_SUCCESS:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Token or user not found')
return Response(result.get_response(), result.get_code())
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())
try:
open_id = request_data['open_id']
address_id = request_data['address_id']
user = User.objects.get(open_id=open_id)
serializer = UserSerializer(user)
user_data = serializer.data
user_info = UserInfo.objects.get(user=user)
serializer = UserInfoSerializer(user_info)
user_info_data = serializer.data
address_manager = AddressManagerV2(logger_info, logger_error)
user_address = address_manager.get_address(open_id, address_id)
if user_address is None:
user_address = ''
result.set('user', user_data)
result.set('user_info', user_info_data)
result.set('user_address', user_address)
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Error : ' + 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
self.logger_info.info(request_data)
dada_manager = DadaManager(self.logger_info, self.logger_error)
try:
# request data validation
dada_util.dada_order_add_tip_validation(request_data)
order_id = request_data['order_id']
tips = request_data['tips']
city_code = request_data['city_code']
info = request_data['info']
# add order tips
dada_manager.add_tip(order_id, tips, city_code, info)
# Read dada detail
dada_order_data = dada_manager.update_order_detail(order_id)
except DataValidationError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_400_BAD_REQUEST, message,
err_code)
except AuthInfoError:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Authentication error')
except BusinessLogicError as instance:
message, err_code, data_set = instance.args
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
message, err_code)
result.set_map(data_set)
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result.set('shipping_order_detail', dada_order_data)
return Response(result.get_response(), result.get_code())
def get(self, request):
# Response object
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
# Get access token
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(
request.META['HTTP_AUTHORIZATION']).split(' ')[1]
page = int(request.GET.get('page'))
limit = int(request.GET.get('limit'))
logger_info.info(open_id + ':' + access_token)
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'Token or user not found')
return Response(result.get_response(), result.get_code())
# Get user list
try:
user_list = list()
users = User.objects.all()
user_count = users.count()
paginator = Paginator(users, limit)
user_objects = paginator.page(page).object_list
serializer = UserSerializer(user_objects, many=True)
user_data = serializer.data
for user in user_data:
user['connection_account'] = json.loads(
user['connection_account'])
user_list.append(user)
result.set('total_count', user_count)
result.set('accounts', user_list)
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data error')
return Response(result.get_response(), result.get_code())
def get(self, request):
auth_info = header_parser.parse_authentication(request)
language_info = header_parser.parse_language(request.META)
event_manager = EventManager(self.logger_info, self.logger_error)
try:
# Get event manager
event_object = event_manager.get_event_status(
auth_info, None, language_info[0])
event = event_object['event']
if event['need_auth']:
user_util.check_auth_info(auth_info)
# Check game play condition
event_util.check_play_condition(event, language_info[0])
# Play the game
reward_result = event_manager.draw_event(event['id'],
language_info[0])
reward_id = reward_result[0]
random_number = reward_result[1]
# Make the history
create_result = event_manager.create_event_history(
event['id'], auth_info[0], reward_id, random_number,
language_info[0])
# Reward interface to purchase server
reward_tuple = create_result[2]
event_manager.create_coupon(auth_info[0], reward_tuple.target_id,
language_info[0])
# Coupon count increase
event_manager.increase_coupon_count(auth_info[0], auth_info[1])
except AuthInfoError as e:
result = ResultResponse(code.ARIES_401_UNAUTHORIZED, str(e))
except BusinessLogicError as instance:
message, err_code = instance.args
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
message)
result.set_error(err_code)
except Exception as e:
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR,
str(e))
else:
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
result.set('event_reward', create_result[1])
return Response(result.get_response(), result.get_code())
def get(self, request, user_id):
# Response object
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
# Get access token
try:
open_id = request.META['HTTP_OPEN_ID']
access_token = str(
request.META['HTTP_AUTHORIZATION']).split(' ')[1]
logger_info.info(open_id + ':' + 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())
# Get User object
try:
# User data
user = User.objects.get(id=user_id)
serializer = UserSerializer(user)
user_data = serializer.data
user_data['connection_account'] = json.loads(
user_data['connection_account'])
user_open_id = user.open_id
addresses = UserAddressInfo.objects.filter(user=user)
serializer = UserAddressInformationSerializer(addresses, many=True)
address_data = serializer.data
address_list = list()
for address in address_data:
address_list.append(address)
headers = {'open-id': user_open_id}
response = requests.get(urlmapper.get_url('COUPON_LIST'),
headers=headers)
if response.status_code == code.ARIES_200_SUCCESS:
response_json = response.json()
coupons = response_json['coupons']
else:
coupons = []
result.set('user', user_data)
result.set('addresses', address_list)
result.set('coupons', coupons)
except ObjectDoesNotExist:
logger_info.info('User not found')
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'User not found')
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Request data error')
return Response(result.get_response(), result.get_code())
def get(self, request, product_id):
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
has_open_id = False
# Get page and limit information
page = int(request.GET.get('page', 1))
limit = int(request.GET.get('limit', 5))
open_id = request.META.get('HTTP_OPEN_ID', None)
if open_id is not None:
has_open_id = True
try:
url = urlmapper.get_url('PRODUCT') + '/' + str(product_id)
response = requests.get(url)
response_json = response.json()
product = response_json['product']
menu = product['menu']
# Menu type check
menu_type = product['type']
menu_id = menu['id']
if menu_type > 10:
result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Product index invalid')
return Response(result.get_response(), result.get_code())
review_lists = list()
review_list = CustomerReview.objects.filter(menu=menu_id, visible=True)
review_total_count = review_list.count()
paginator = Paginator(review_list, limit)
review_objects = paginator.page(page).object_list
serializer = CustomerReviewSerializer(review_objects, many=True)
review_objects_data = serializer.data
for review in review_objects_data:
date_str = review['created_date']
review['created_date'] = date_str[:10]
if has_open_id and open_id == review['open_id']:
review['editable'] = True
else:
review['editable'] = False
del review['menu']
del review['open_id']
del review['visible']
review_lists.append(review)
result.set('total_count', review_total_count)
result.set('page_size', limit)
result.set('customer_reviews', review_lists)
except Exception as e:
logger_error.error(str(e))
result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Paging error')
return Response(result.get_response(), code.ARIES_500_INTERNAL_SERVER_ERROR)
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 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 get(self, request, login_key):
verification_code = str(cache.get(login_key))
logger_info.info(login_key + ':' + str(cache.get(login_key)))
if len(verification_code) < 6:
logger_error.error('Unauthorized')
result = ResultResponse(code.ARIES_401_UNAUTHORIZED,
'It needs verification')
return Response(result.get_response(), result.get_code())
try:
cache_data = cache.get(login_key)
if cache_data == 'complete':
result = ResultResponse(code.ARIES_200_SUCCESS, 'success')
else:
logger_info.info('verification failed')
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Verification failed')
return Response(result.get_response(), result.get_code())
except Exception as e:
logger_info.info(str(e))
result = ResultResponse(code.ARIES_400_BAD_REQUEST,
'Verification failed')
return Response(result.get_response(), result.get_code())
return Response(result.get_response(), result.get_code())
