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 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(self, request): auth_info = header_parser.parse_authentication(request) language_info = header_parser.parse_language(request.META) try: coupon_util.auth_info_validator(auth_info, language_info[0]) coupon_util.os_info_validator(request) coupon_manager = CouponManagerV3(logger_info, logger_error) coupon_manager.create_coupon_pack(auth_info, self.coupon_pack_info, language_info[0]) 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') 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 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): 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 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, 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): 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 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 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 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 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 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): 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 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())
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 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 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 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 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 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 sign_up(self, login_type, request_data): if login_type == QQ_APPLICATION: login_key = request_data['login_sns_open_id'] login_sns_open_id = request_data['login_sns_open_id'] login_sns_access_token = request_data['login_sns_access_token'] # Auto sign-up section login_value = '' login_sns_refresh_token = '' # 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 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 user_instance = User.objects.create( open_id=open_id, mdn='', name=open_id[:6], mdn_verification=False, access_token=token, parent_type=QQ_APPLICATION ) UserLoginInfo.objects.create( user=user_instance, login_type=QQ_APPLICATION, 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 ) 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_notify_info = UserNotifyInfo.objects.get(user=user_instance) user_notify_info.coupon_count = 1 user_notify_info.save() # Connection information user_instance.connection_count = F('connection_count') + 1 connect_info = json.loads(user_instance.connection_account) connect_info.append({'login_type': QQ_APPLICATION, 'login_sns_open_id': login_sns_open_id}) user_instance.connection_account = json.dumps(connect_info) user_instance.save() login_info = UserLoginInfo.objects.get(login_sns_open_id=login_sns_open_id) auto_registration = True result = (login_info, login_sns_open_id, auto_registration) elif login_type == WECHAT_APPLICATION or login_type == WECHAT_PUBLIC: login_key = request_data['login_key'] login_value = request_data['login_value'] login_sns_open_id = request_data['login_sns_open_id'] login_sns_access_token = request_data['login_sns_access_token'] login_sns_refresh_token = request_data['login_sns_refresh_token'] # 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 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 user_instance = User.objects.create( open_id=open_id, mdn='', name=open_id[:6], mdn_verification=False, access_token=token, parent_type=WECHAT_APPLICATION ) UserLoginInfo.objects.create( user=user_instance, login_type=WECHAT_APPLICATION, 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 ) 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_notify_info = UserNotifyInfo.objects.get(user=user_instance) user_notify_info.coupon_count = 1 user_notify_info.save() # Connection information user_instance.connection_count = F('connection_count') + 1 connect_info = json.loads(user_instance.connection_account) connect_info.append({'login_type': WECHAT_APPLICATION, 'login_sns_open_id': login_sns_open_id}) user_instance.connection_account = json.dumps(connect_info) user_instance.save() login_info = UserLoginInfo.objects.get(login_sns_open_id=login_sns_open_id) result = (login_info, login_sns_open_id, True) elif login_type == QQ_MOBILE: login_key = request_data['login_key'] login_value = request_data['login_value'] login_sns_open_id = request_data['login_sns_open_id'] login_sns_access_token = request_data['login_sns_access_token'] login_sns_refresh_token = request_data['login_sns_refresh_token'] # 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 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 user_instance = User.objects.create( open_id=open_id, mdn='', name=open_id[:6], mdn_verification=False, access_token=token, parent_type=QQ_APPLICATION ) UserLoginInfo.objects.create( user=user_instance, login_type=QQ_APPLICATION, 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 ) 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_notify_info = UserNotifyInfo.objects.get(user=user_instance) user_notify_info.coupon_count = 1 user_notify_info.save() # Connection information user_instance.connection_count = F('connection_count') + 1 connect_info = json.loads(user_instance.connection_account) connect_info.append({'login_type': QQ_APPLICATION, 'login_sns_open_id': login_sns_open_id}) user_instance.connection_account = json.dumps(connect_info) user_instance.save() login_info = UserLoginInfo.objects.get(login_sns_open_id=login_sns_open_id) result = (login_info, login_sns_open_id, True) elif login_type == MDN_QUICK: login_type = request_data['login_type'] login_key = request_data['login_key'] login_value = '' login_sns_open_id = '' login_sns_access_token = '' login_sns_refresh_token = '' # 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 payload = {'user_open_id': open_id, 'user_account': login_key} 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 user_instance = User.objects.create( open_id=open_id, mdn=login_key, name=login_key, mdn_verification=True, access_token=token, parent_type=MDN_QUICK ) 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 ) 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_notify_info = UserNotifyInfo.objects.get(user=user_instance) user_notify_info.coupon_count = 1 user_notify_info.save() # 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() user_login_info = UserLoginInfo.objects.get(login_key=login_key) result = (user_login_info, login_key, True) else: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'NOT SUPPORT LOGIN TYPE') result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED) return Response(result.get_response(), result.get_code()) return result