def post(self, request): logger_info.info(request.data) access_token = '' open_id = '' try: access_token = str( request.META['HTTP_AUTHORIZATION']).split(' ')[1] open_id = request.META['HTTP_OPEN_ID'] user_count = User.objects.filter( open_id=open_id, access_token=access_token).count() if user_count == 1: user_info = True else: user_info = False except Exception as e: logger_info.info(str(e)) user_info = False try: mdn = request.data['mdn'] verification_code = request.data['verification_code'] today = datetime.datetime.today() sms_auth_count = SmsAuthHistory.objects.filter( date=today, target_mdn=mdn).count() if sms_auth_count == 0: result = ResultResponse(code.ARIES_400_BAD_REQUEST, "Request data validation fail") return Response(result.get_response(), result.get_code()) sms_auth = SmsAuthHistory.objects.filter( date=today, target_mdn=mdn).latest('id') system_code = sms_auth.verification_code if system_code == verification_code: sms_auth.verification_count += 1 sms_auth.has_verified = True else: sms_auth.verification_count += 1 sms_auth.save() except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, "Request data validation fail") return Response(result.get_response(), result.get_code()) cache_data = cache.get(mdn) if cache_data is None: logger_info.info('verify code is not found') result = ResultResponse(code.ARIES_400_BAD_REQUEST, "Verify code is not found") return Response(result.get_response(), result.get_code()) if verification_code == cache_data: # Verification success cache.set(mdn, 'complete', 300) # Update user information logger_info.info(user_info) if user_info: try: # Original user information original_user = User.objects.get(open_id=open_id, access_token=access_token) # Check if already verification member user_login_count = UserLoginInfo.objects.filter( login_key=mdn).count() before_mdn_user_count = User.objects.filter( mdn=mdn).count() if user_login_count == 0 and before_mdn_user_count == 1: before_user = User.objects.get(mdn=mdn) if before_user.open_id == original_user.open_id: original_user.mdn_verification = True else: # 20180130 check original_user.mdn = mdn before_user.mdn = '' before_user.mdn_verification = False original_user.save() before_user.save() elif user_login_count == 1: user_login_info = UserLoginInfo.objects.get( login_key=mdn) user = user_login_info.user if user.open_id != original_user.open_id: # Other mobile member case if "010" in user.name: user.name = user.open_id[:6] user.mdn = '' user.mdn_verification = False user.save() new_mdn = 'dormant_' + mdn + '_' + ( '%04d' % random.randint(1, 9999)) user_login_info.login_key = new_mdn user_login_info.save() # Send push service sender = SmsIdSender(mdn, new_mdn) sender.start() # Original user information save if "010" in original_user.name: original_user.name = mdn original_user.mdn = mdn original_user.mdn_verification = True original_user.save() login_count = UserLoginInfo.objects.filter( user=original_user, login_type=0).count() if login_count == 1: user_login_origin = UserLoginInfo.objects.get( user=original_user, login_type=0) user_login_origin.login_key = mdn user_login_origin.save() # Original user login information delete payload = { 'user_open_id': user.open_id, 'user_account': mdn } response = requests.delete( urlmapper.get_url('PLATFORM_SERVER'), json=payload) logger_info.info(response.text) else: # login info is same user_login_info.login_key = mdn user_login_info.save() original_user.mdn = mdn original_user.mdn_verification = True original_user.save() else: # Check if parent type if original_user.parent_type == 0: original_user_mdn = original_user.mdn original_login_info = UserLoginInfo.objects.get( user=original_user, login_key=original_user_mdn) original_login_info.login_key = mdn original_login_info.save() # SNS member original_user.mdn = mdn original_user.mdn_verification = True original_user.save() except Exception as e: logger_error.error(str(e)) result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, code_msg.get_msg( code.ERROR_1003_SMS_VERIFICATION_FAILURE)) result.set_error(code.ERROR_1003_SMS_VERIFICATION_FAILURE) return Response(result.get_response(), result.get_code()) result = ResultResponse(code.ARIES_200_SUCCESS, "SMS verification success") else: logger_info.info('Verification code is different') result = ResultResponse(code.ARIES_400_BAD_REQUEST, "Verification code is different") return Response(result.get_response(), result.get_code()) return Response(result.get_response(), result.get_code())
def post(self, request): request_data = request.data result = ResultResponse(code.ARIES_200_SUCCESS, 'success') logger_info.info(request_data) # Get access token try: open_id = request.META['HTTP_OPEN_ID'] access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1] except Exception as e: logger_error.error(str(e)) result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Token or user not found') return Response(result.get_response(), result.get_code()) # Request data parsing try: product_id = request_data['product_id'] order_id = request_data['order_id'] headers = {'open-id': open_id, 'AUTHORIZATION': 'bearer ' + access_token} response = requests.get(urlmapper.get_url('PRODUCT') + '/' + str(product_id), headers=headers) response_json = response.json() product = response_json['product'] menu = product['menu'] menu_id = menu['id'] if request_data['menu_rate'] == 0: request_data['menu_rate'] = 5 request_data['open_id'] = open_id request_data['product_id'] = product_id request_data['menu'] = menu_id request_data['has_reviewed'] = True # Check selective review object comment = request_data['comment'] if len(comment) <= 1: request_data['visible'] = False else: request_data['visible'] = True except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) # Check if review exists try: review_count = CustomerReview.objects.filter( open_id=open_id, product_id=product_id, order_id=order_id ).count() # Not exists review if review_count <= 0: serializer = CustomerReviewSerializer(data=request_data) if serializer.is_valid(): serializer.save() review_data = serializer.data if open_id == review_data['open_id']: review_data['editable'] = True else: review_data['editable'] = False del review_data['created_date'] del review_data['menu'] del review_data['open_id'] # If review article saved, send Review Detail result.set('review_detail', review_data) # Statics information apply payload = {'menu_id': menu_id, 'menu_rate': request_data['menu_rate'], 'has_reviewed': False, 'menu_prev_rate': 0.0} statics_result = requests.post(urlmapper.get_url('MENU_STATICS'), json=payload) logger_info.info(statics_result.text) else: logger_info.info(serializer.errors) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) else: review = CustomerReview.objects.get(open_id=open_id, product_id=product_id, order_id=order_id) prev_rate = review.menu_rate serializer = CustomerReviewSerializer(review, data=request_data, partial=True) if serializer.is_valid(): serializer.save() review_data = serializer.data if open_id == review_data['open_id']: review_data['editable'] = True else: review_data['editable'] = False del review_data['created_date'] del review_data['menu'] del review_data['open_id'] result.set('review_detail', review_data) # Statics information apply payload = {'menu_id': menu_id, 'menu_rate': request_data['menu_rate'], 'has_reviewed': True, 'menu_prev_rate': prev_rate} statics_result = requests.post(urlmapper.get_url('MENU_STATICS'), json=payload) logger_info.info(statics_result.text) else: logger_info.info(serializer.errors) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) return Response(result.get_response(), result.get_code())
def put(self, request): request_data = request.data result = ResultResponse(code.ARIES_200_SUCCESS, 'success') logger_info.info(request_data) # AUthorization check try: open_id = request.META['HTTP_OPEN_ID'] access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1] url = urlmapper.get_url('TOKEN_VALIDATE') headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token} response = requests.get(url, headers=headers) if response.status_code != 200: raise Exception except Exception as e: print(e) result = ResultResponse(code.ARIES_401_UNAUTHORIZED, get_msg(code.ARIES_401_UNAUTHORIZED)) return Response(result.get_response(), result.get_code()) # Request data parsing try: # Check selective review object product_id = request_data['product_id'] comment = request_data['comment'] if len(comment) <= 0: request_data['visible'] = False else: request_data['visible'] = True except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) review = CustomerReview.objects.get(open_id=open_id, product_id=product_id) serializer = CustomerReviewSerializer(review, data=request_data, partial=True) if serializer.is_valid(): serializer.save() # Statics information apply payload = {'menu_id': review.menu, 'prev_rate': review.menu_rate, 'menu_rate': request_data['menu_rate']} statics_result = requests.put(urlmapper.get_url('MENU_STATICS'), json=payload) logger_info.info(statics_result.text) else: logger_info.info(serializer.errors) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) return Response(result.get_response(), result.get_code())
def post(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') request_data = request.data self.logger_info.info(request_data) dada_manager = DadaManager(self.logger_info, self.logger_error) try: # request data validation dada_util.dada_new_order_validation(request_data) order_id = request_data['order_id'] receiver_address = request_data['receiver_address'] receiver_lat = request_data['receiver_lat'] receiver_lng = request_data['receiver_lng'] # Make a new order dada_manager.add_order(request_data) # Make a new order detail dada_manager.add_order_detail(order_id, receiver_address, receiver_lat, receiver_lng) # Read dada order detail dada_order_data = dada_manager.read_order_detail(order_id) except DataValidationError as instance: message, err_code = instance.args result = ResultResponse(code.ARIES_400_BAD_REQUEST, message, err_code) except AuthInfoError: result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authentication error') except BusinessLogicError as instance: message, err_code, data_set = instance.args result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, message, err_code) result.set_map(data_set) except Exception as e: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) else: result.set('shipping_order_detail', dada_order_data) return Response(result.get_response(), result.get_code())
def get(self, request): auth_info = header_parser.parse_authentication(request) language_info = header_parser.parse_language(request.META) event_manager = EventManager(self.logger_info, self.logger_error) try: event = event_manager.get_event_status(auth_info, None, language_info[0]) except Exception as e: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) else: result = ResultResponse(code.ARIES_200_SUCCESS, 'success') result.set('event', event['event']) result.set('event_reward', event['event_reward']) result.set('event_info', event['event_info']) return Response(result.get_response(), result.get_code())
def get(self, request, order_id): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') auth_info = header_parser.parse_auth_info(request) self.logger_info.info(auth_info.access_token) dada_manager = DadaManager(self.logger_info, self.logger_error) try: # Read dada detail dada_order_data = dada_manager.read_order_detail(order_id) except DataValidationError as instance: message, err_code = instance.args result = ResultResponse(code.ARIES_400_BAD_REQUEST, message, err_code) except AuthInfoError: result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authentication error') except BusinessLogicError as instance: message, err_code, data_set = instance.args result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, message, err_code) result.set_map(data_set) except Exception as e: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) else: result.set('shipping_order_detail', dada_order_data) return Response(result.get_response(), result.get_code())
def post(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') request_data = request.data self.logger_info.info(request_data) dada_manager = DadaManager(self.logger_info, self.logger_error) try: # request data validation dada_util.dada_order_add_after_query_validation(request_data) # Make a new order query_result = dada_manager.order_add_after_query(request_data) except DataValidationError as instance: message, err_code = instance.args result = ResultResponse(code.ARIES_400_BAD_REQUEST, message, err_code) except AuthInfoError: result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authentication error') except BusinessLogicError as instance: message, err_code, data_set = instance.args result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, message, err_code) result.set_map(data_set) except Exception as e: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) else: result.set_map(query_result) return Response(result.get_response(), result.get_code())
def post(self, request): print(request.data) request_data = request.data logger_info.info(request_data) sign_obj = Sign() # Get access token try: open_id = request.META['HTTP_OPEN_ID'] access_token = str( request.META['HTTP_AUTHORIZATION']).split(' ')[1] sign_obj.login_type = request_data['login_type'] sign_obj.login_sns_open_id = request_data['login_sns_open_id'] sign_obj.login_sns_access_token = request_data[ 'login_sns_access_token'] sign_obj.login_sns_refresh_token = '' user = User.objects.get(open_id=open_id, access_token=access_token) except Exception as e: logger_error.error(str(e)) result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Token or user not found') return Response(result.get_response(), result.get_code()) if sign_obj.login_type == 0: result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Not supported connect method') return Response(result.get_response(), result.get_code()) # Check login information try: if sign_obj.login_type == 1: # In case of QQ login_info_count = UserLoginInfo.objects.filter( login_sns_open_id=sign_obj.login_sns_open_id).count() if login_info_count >= 1: result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, code_msg.get_msg( code.ERROR_1010_USER_ALREADY_CONNECTION)) result.set_error(code.ERROR_1010_USER_ALREADY_CONNECTION) return Response(result.get_response(), result.get_code()) UserLoginInfo.objects.create( user=user, login_type=sign_obj.login_type, login_key=sign_obj.login_key, login_value=sign_obj.login_value, login_sns_open_id=sign_obj.login_sns_open_id, login_sns_access_token=sign_obj.login_sns_access_token, login_sns_refresh_token=sign_obj.login_sns_refresh_token) user.connection_count += 1 connect_info = json.loads(user.connection_account) new_info = { 'login_type': sign_obj.get_login_type(), 'login_sns_open_id': sign_obj.login_sns_open_id } connect_info.append(new_info) user.connection_account = json.dumps(connect_info) user.save() result = ResultResponse(code.ARIES_200_SUCCESS, 'success') result.set('login_type', sign_obj.get_login_type()) result.set('login_sns_open_id', sign_obj.login_sns_access_token) return Response(result.get_response(), result.get_code()) elif sign_obj.login_type == 2 or sign_obj.login_type == 3: # WeChat SNS login login_sns_open_id = request_data['login_sns_open_id'] if sign_obj.login_type == 2: # WeChat app login payload = { 'appid': 'wx87010cb61b99206d', 'secret': '21b9cf8d51b704fd244f40b351d7876e', 'code': login_sns_open_id, 'grant_type': 'authorization_code' } else: # WeChat public account login payload = { 'appid': 'wx41b86399fee7a2ec', 'secret': '1b3d5dce9860be7e4fc04847df6a6177', 'code': login_sns_open_id, 'grant_type': 'authorization_code' } sign_obj.login_type = 2 response = requests.get(resources.WECHAT_ACCESS_TOKEN_URL, params=payload) if response.status_code != code.ARIES_200_SUCCESS: result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, code_msg.get_msg( code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)) result.set_error(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL) logger_error.error( code_msg.get_msg( code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)) return Response(result.get_response(), result.get_code()) response_json = response.json() print(response.text) if response_json.get('unionid'): sign_obj.login_key = response_json['openid'] sign_obj.login_value = '' sign_obj.login_sns_open_id = response_json['unionid'] sign_obj.login_sns_access_token = response_json[ 'access_token'] sign_obj.login_sns_refresh_token = response_json[ 'refresh_token'] wechat_count = UserLoginInfo.objects.filter( login_type=sign_obj.login_type, login_sns_open_id=sign_obj.login_sns_open_id).count() if wechat_count >= 1: result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, code_msg.get_msg( code.ERROR_1010_USER_ALREADY_CONNECTION)) result.set_error( code.ERROR_1010_USER_ALREADY_CONNECTION) logger_error.error( code_msg.get_msg( code.ERROR_1010_USER_ALREADY_CONNECTION)) return Response(result.get_response(), result.get_code()) else: result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, code_msg.get_msg( code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)) result.set_error(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL) logger_error.error( code_msg.get_msg( code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)) return Response(result.get_response(), result.get_code()) UserLoginInfo.objects.create( user=user, login_type=sign_obj.login_type, login_key=sign_obj.login_key, login_value=sign_obj.login_value, login_sns_open_id=sign_obj.login_sns_open_id, login_sns_access_token=sign_obj.login_sns_access_token, login_sns_refresh_token=sign_obj.login_sns_refresh_token) user.connection_count += 1 connect_info = json.loads(user.connection_account) new_info = { 'login_type': sign_obj.get_login_type(), 'login_sns_open_id': sign_obj.login_sns_open_id } connect_info.append(new_info) user.connection_account = json.dumps(connect_info) user.save() result = ResultResponse(code.ARIES_200_SUCCESS, 'success') result.set('login_type', sign_obj.get_login_type()) result.set('login_sns_open_id', sign_obj.login_sns_open_id) return Response(result.get_response(), result.get_code()) elif sign_obj.login_type == 4: # QQ mobile web connect login_sns_open_id = request_data['login_sns_open_id'] payload = { 'grant_type': 'authorization_code', 'client_id': '1106290901', 'client_secret': 'WbcNyj80WeBvgoSs', 'code': login_sns_open_id, 'redirect_uri': 'https://api.viastelle.com/users/signin/callback' } response = requests.get(resources.QQ_ACCESS_TOKEN_URL, params=payload) print(response.text) res_text = response.text if 'access_token' in res_text: res_json = json.loads(json.dumps(parse_qs(res_text))) qq_access_token = res_json['access_token'][0] qq_exprires_in = res_json['expires_in'][0] qq_refresh_token = res_json['refresh_token'][0] payload = {'access_token': qq_access_token} response = requests.get(resources.QQ_OPEN_ID_URL, params=payload) res_text = response.text logger_info.info(res_text) split_res = res_text.split(' ') json_result = json.loads(split_res[1]) response_openid = json_result['openid'] login_sns_access_token = response_openid qq_count = UserLoginInfo.objects.filter( login_sns_open_id=login_sns_access_token).count() if qq_count >= 1: result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, code_msg.get_msg( code.ERROR_1010_USER_ALREADY_CONNECTION)) result.set_error( code.ERROR_1010_USER_ALREADY_CONNECTION) logger_error.error( code_msg.get_msg( code.ERROR_1010_USER_ALREADY_CONNECTION)) return Response(result.get_response(), result.get_code()) UserLoginInfo.objects.create( user=user, login_type=sign_obj.get_login_type(), login_key='', login_value='', login_sns_open_id=login_sns_access_token, login_sns_access_token=qq_access_token, login_sns_refresh_token=qq_refresh_token) else: result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_1101_NOT_SUPPORTED_FILE_FORMAT)) result.set_error(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL) logger_error.error( get_msg(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)) return Response(result.get_response(), result.get_code()) user.connection_count += 1 connect_info = json.loads(user.connection_account) new_info = { 'login_type': sign_obj.get_login_type(), 'login_sns_open_id': login_sns_access_token } connect_info.append(new_info) user.connection_account = json.dumps(connect_info) user.save() result = ResultResponse(code.ARIES_200_SUCCESS, 'success') result.set('login_type', sign_obj.get_login_type()) result.set('login_sns_open_id', login_sns_access_token) return Response(result.get_response(), result.get_code()) else: result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) except Exception as e: print(e) result = ResultResponse(code.ARIES_400_BAD_REQUEST, e) return Response(result.get_response(), result.get_code())
def put(self, request, receipt_id): request_data = request.data self.logger_info.info('[UserReceiptDetail][put][' + str(request_data) + ']') auth_info = header_parser.parse_auth_info(request) lang_info = parse_language_v2(request.META) try: check_auth_info_v2(auth_info.open_id, auth_info.access_token) receipt_util.request_validation(auth_info.open_id, request_data) receipt_manager = ReceiptManager(self.logger_info, self.logger_error) receipt_list = receipt_manager.update_user_receipt( auth_info.open_id, int(receipt_id), request_data, lang_info.cn_header) except DataValidationError as instance: message, err_code = instance.args result = ResultResponse(code.ARIES_400_BAD_REQUEST, message, err_code) except AuthInfoError: result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authentication error') except BusinessLogicError as instance: message, err_code, data_set = instance.args result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, message, err_code) result.set_map(data_set) except Exception as e: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) else: result = ResultResponse(code.ARIES_200_SUCCESS, 'success') result.set('user_receipts', receipt_list) return Response(result.get_response(), result.get_code())
def post(self, request): request_data = request.data target_db = 'default' cn_header = False if request.META.get('HTTP_ACCEPT_LANGUAGE'): accept_lang = request.META['HTTP_ACCEPT_LANGUAGE'] if 'zh' in accept_lang: target_db = 'aries_cn' cn_header = True if cn_header: self.SUCCESS = self.SUCCESS_CN result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS) # Request data parsing try: open_id = request.META['HTTP_OPEN_ID'] access_token = str( request.META['HTTP_AUTHORIZATION']).split(' ')[1] logger_info.info(open_id + ':' + access_token) serial_number = request_data['serial_number'] except Exception as e: print(e) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid(Token or Open id)') return Response(result.get_response(), result.get_code()) # Validation check try: payload = {'open_id': open_id, 'access_token': access_token} url = urlmapper.get_url('USER_VALIDATION') response = requests.post(url, json=payload) if response.status_code != code.ARIES_200_SUCCESS: result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authorization error') return Response(result.get_response(), result.get_code()) promotion_coupon_count = EventCoupon.objects.filter( serial_number=serial_number).count() if promotion_coupon_count <= 0: if cn_header: self.COUPON_NOT_EXISTS = self.COUPON_NOT_EXISTS_CN result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, self.COUPON_NOT_EXISTS) return Response(result.get_response(), result.get_code()) promotion_coupon = EventCoupon.objects.get( serial_number=serial_number) event_type = promotion_coupon.event_type if promotion_coupon.name == open_id: if cn_header: self.SELF_ISSUED = self.SELF_ISSUED_CN result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, self.SELF_ISSUED) return Response(result.get_response(), result.get_code()) coupon_code = promotion_coupon.coupon_code customer_coupon_count = CustomerCoupon.objects.filter( open_id=open_id, coupon_code=coupon_code).count() if customer_coupon_count >= 1 and (event_type == 0 or event_type == 2): if cn_header: self.COUPON_KIND_LIMITATION = self.COUPON_KIND_LIMITATION_CN result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, self.COUPON_KIND_LIMITATION) return Response(result.get_response(), result.get_code()) if promotion_coupon.issued and event_type != 2: if cn_header: self.ALREADY_ISSUED = self.ALREADY_ISSUED_CN result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, self.ALREADY_ISSUED) return Response(result.get_response(), result.get_code()) if event_type == 2 and promotion_coupon.issued_limitation != 0 \ and promotion_coupon.issued_count+1 > promotion_coupon.issued_limitation: if cn_header: self.COUPON_COUNT_LIMITATION = self.COUPON_COUNT_LIMITATION_CN result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, self.COUPON_COUNT_LIMITATION) return Response(result.get_response(), result.get_code()) if not promotion_coupon.has_coupon_pack: today = date.today() coupon_count = Coupon.objects.using(target_db).filter( id=promotion_coupon.coupon_id, period_start_date__lte=today, period_end_date__gte=today).count() if coupon_count <= 0: if cn_header: self.PROMOTION_EXPIRED = self.PROMOTION_EXPIRED_CN result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, self.PROMOTION_EXPIRED) return Response(result.get_response(), result.get_code()) except Exception as e: print(e) logger_error.error(str(e)) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) return Response(result.get_response(), result.get_code()) # Coupon create try: coupon_id_list = list() today = date.today() if promotion_coupon.has_coupon_pack: coupon_pack_list = json.loads(promotion_coupon.coupon_pack) for coupon_item in coupon_pack_list: coupon = Coupon.objects.using(target_db).get( id=coupon_item['id']) coupon_dates = product_util.get_coupon_date( coupon.period_type, coupon.period_day, coupon.period_start_date, coupon.period_end_date) for index in range(coupon_item['quantity']): customer_coupon = CustomerCoupon.objects.create( coupon=coupon, coupon_code=coupon_code, open_id=open_id, issue_date=today, start_date=coupon_dates[0], end_date=coupon_dates[1], sender_id=promotion_coupon.name, status=0) coupon_id_list.append(customer_coupon.id) else: coupon = Coupon.objects.using(target_db).get( id=promotion_coupon.coupon_id) coupon_dates = product_util.get_coupon_date( coupon.period_type, coupon.period_day, coupon.period_start_date, coupon.period_end_date) created_coupon_count = promotion_coupon.coupon_count for index in range(created_coupon_count): customer_coupon = CustomerCoupon.objects.create( coupon=coupon, coupon_code=coupon_code, open_id=open_id, issue_date=today, start_date=coupon_dates[0], end_date=coupon_dates[1], sender_id=promotion_coupon.name, status=0) coupon_id_list.append(customer_coupon.id) coupon_count = len(coupon_id_list) if promotion_coupon.issued_limitation != 0: promotion_coupon.issued_count = F('issued_count') + 1 promotion_coupon.issued = True promotion_coupon.issued_date = today promotion_coupon.issued_user_open_id = open_id promotion_coupon.issued_customer_coupon_id = str(coupon_id_list) promotion_coupon.save() # Coupon count up headers = { 'open-id': open_id, 'authorization': 'bearer ' + access_token } url = urlmapper.get_url('USER_NOTIFICATION') + '/coupon/0/' + str( coupon_count) response = requests.get(url, headers=headers) logger_info.info(response.text) # After coupon issued, response current coupon list default_page = 1 default_limit = 100 expired_date = 7 coupon_manager = CouponManagerV3(logger_info, logger_error) coupon_list = coupon_manager.get_coupon_list( open_id, access_token, target_db, default_page, default_limit, expired_date) result.set('coupon_id', coupon_id_list) result.set_map(coupon_list) return Response(result.get_response(), result.get_code()) except Exception as e: print(e) logger_error.error(str(e)) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) return Response(result.get_response(), result.get_code())
def put(self, request): request_data = request.data logger_info.info(request_data) sign_obj = Sign() # Get access token try: open_id = request.META['HTTP_OPEN_ID'] access_token = str( request.META['HTTP_AUTHORIZATION']).split(' ')[1] sign_obj.login_type = request_data['login_type'] sign_obj.login_sns_open_id = request_data['login_sns_open_id'] sign_obj.login_sns_access_token = '' sign_obj.login_sns_refresh_token = '' user = User.objects.get(open_id=open_id, access_token=access_token) except Exception as e: logger_error.error(str(e)) result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Token or user not found') return Response(result.get_response(), result.get_code()) try: login_info = UserLoginInfo.objects.filter( user=user, login_sns_open_id=sign_obj.login_sns_open_id) count = UserLoginInfo.objects.filter(user=user).count() if (count - login_info.count()) <= 0: result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, code_msg.get_msg(code.ERROR_1013_ONLY_ONE_LOGIN_INFO)) result.set_error(code.ERROR_1013_ONLY_ONE_LOGIN_INFO) logger_error.error( code_msg.get_msg(code.ERROR_1013_ONLY_ONE_LOGIN_INFO)) return Response(result.get_response(), result.get_code()) if login_info.count() == 1: login_info = UserLoginInfo.objects.get( user=user, login_sns_open_id=sign_obj.login_sns_open_id) login_info.delete() if user.connection_count == 2 and user.parent_type != 0: # Full connection count - WeChat, QQ # Delete success and change access_token if sign_obj.login_type == 1 or sign_obj.login_type == 4: # Delete QQ account, get a wechat account new_login_info = UserLoginInfo.objects.get( user=user, login_type=2) else: # Delete wechat account, get a qq account new_login_info = UserLoginInfo.objects.get( user=user, login_type=1) payload = { 'user_open_id': open_id, 'user_account': login_info.login_sns_open_id, 'new_user_account': new_login_info.login_sns_open_id } response = requests.put( urlmapper.get_url('PLATFORM_SERVER'), json=payload) logger_info.info(response.text) connect_info = json.loads(user.connection_account) logger_info.info(connect_info) if connect_info.remove({ 'login_type': sign_obj.login_type, 'login_sns_open_id': sign_obj.login_sns_open_id }): user.connection_account = json.dumps(connect_info) user.connection_count -= 1 user.save() else: user.connection_account = json.dumps(connect_info) user.connection_count -= 1 user.save() result = ResultResponse(code.ARIES_200_SUCCESS, 'success') result.set('login_type', sign_obj.login_type) result.set('login_sns_open_id', sign_obj.login_sns_open_id) return Response(result.get_response(), result.get_code()) else: result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, code_msg.get_msg(code.ERROR_1012_LOGIN_INFO_NOT_FOUND)) result.set_error(code.ERROR_1012_LOGIN_INFO_NOT_FOUND) return Response(result.get_response(), result.get_code()) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, e) return Response(result.get_response(), result.get_code())
def get(self, request, product_id): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') lang_info = parse_language_v2(request.META) target_db = lang_info.target_db os_type = lang_info.os_type cn_header = lang_info.cn_header product_queryset = Product.objects.filter(id=product_id, type__lte=10) product_count = product_queryset.count() if product_count < 1: result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Product not found') return Response(result.get_response(), status=result.get_code()) # Create manager product_manager = ProductManagerV3(logger_info, logger_error) menu_manager = MenuManagerV2(logger_info, logger_error) review_manager = ReviewManager(logger_info, logger_error) # Get product information product = product_manager.get_product_data(product_id) hub_id = product['hub'] # Parsing menu and restaurant data menu_manager.get_menu_data(product, target_db, cn_header) result.set('product', product) # Recommend product information product_list = product_manager.get_recommend_product(hub_id) for product_obj in product_list: menu_manager.get_menu_data(product_obj, target_db, cn_header) result.set('products', product_list) # Time bomb information time_bomb_manager = TimeBombManager(self.logger_info, self.logger_error) time_bomb_id = time_bomb_manager.get_time_bomb_now(hub_id, os_type, has_after=False) if time_bomb_id is not None: discount_map = product_manager.get_all_discount_info(time_bomb_id, cn_header) if product['id'] in discount_map: discount_info = discount_map[product['id']] add_discount_information(product, discount_info) # Expert review expert_review = review_manager.get_expert_review(target_db, product['menu']['id']) result.set('expert_review', expert_review) # Review articles # reviews = review_manager.get_product_review(language_info[2], product_id) result.set('total_count', 0) result.set('page_size', 0) result.set('customer_reviews', []) return Response(result.get_response(), status=result.get_code())
def post(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS_MSG) language_info = header_parser.parse_language(request.META) cn_header = language_info[0] target_db = language_info[1] result_list = list() result_product_list = list() try: request_data = request.data os_type = request_data.get('os_type', 0) hub_id = request_data.get('hub_id', 1) product_list = request.data['product_list'] delivery_schedule = request.data['delivery_schedule'] except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) first_product = True product_order_name = '' sales_time = 0 # Time bomb service product_service = ProductService(logger_info, logger_error) time_bomb_service = TimeBombService(logger_info, logger_error) time_bomb_id = time_bomb_service.get_current_time_bomb_id(hub_id, os_type) discount_info = {} if time_bomb_id is not None: discount_list = product_service.read_product_discount_info_with_id(time_bomb_id) discount_info.update(get_discount_info_map(discount_list, cn_header)) for product in product_list: try: product_instance = Product.objects.get(id=product['product_id']) menu_instance = Menu.objects.using(target_db).get(id=product_instance.menu.id) hub_stock = HubStock.objects.get(hub=product_instance.hub, menu=menu_instance) # Check sales_time sales_time = product_instance.sales_time # Check real stock unit order_quantity = product['quantity'] stock = hub_stock.stock if stock < order_quantity: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Product already sold') error_code = code.ERROR_3001_PRODUCT_ALREADY_SOLD result.set_error(error_code) error_message = get_msg(error_code, cn_header) error_message += ' [' + menu_instance.name + ']' result.set_error_message(error_message) return Response(result.get_response(), result.get_code()) # Check schedule time if not check_delivery_schedule(delivery_schedule): result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Schedule invalid') error_code = code.ERROR_3015_PRODUCT_DELIVERY_TIME_INVALID error_message = get_msg(error_code, cn_header) result.set_error(error_code) result.set_error_message(error_message) return Response(result.get_response(), result.get_code()) # Product information product_serializer = ProductListInfoSerializer(product_instance) product_data = product_serializer.data menu_serializer = MenuValidationSerializer(menu_instance) menu_data = menu_serializer.data product_data['menu'] = menu_data product_data['quantity'] = product['quantity'] # Add time bomb information if product_data['id'] in discount_info: add_discount_information(product_data, discount_info[product_data['id']]) result_product_list.append(product_data) if first_product: product_order_name = product_instance.menu.name # product_order_name = menu_instance.name first_product = False logger_info.info(str(stock) + ' ' + str(product['quantity'])) if stock >= product['quantity']: result_list.append(product['product_id']) except Exception as e: print(e) result.set('product_title', product_order_name) # Check if result list is zero, don't display more if int(len(result_list)-1) != 0: result.set('product_sub', '(and ' + str(len(result_list)-1) + ' more)') else: result.set('product_sub', '') result.set('sales_time', sales_time) result.set('product_count', len(result_list)) result.set('product_index_list', result_list) result.set('product_list', result_product_list) return Response(result.get_response(), result.get_code())
def post(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') request_data = request.data logger_info.info(request_data) mdn = request_data['mdn'] is_english = True if request.META.get('HTTP_ACCEPT_LANGUAGE'): accept_lang = request.META['HTTP_ACCEPT_LANGUAGE'] if 'zh' in accept_lang: is_english = False if len(mdn) <= 10: result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) if 'sms_type' in request_data and request_data['sms_type'] == 1: user_count = User.objects.filter(mdn=mdn).count() del request_data['sms_type'] if user_count >= 1: error_code = code.ERROR_1005_USER_ALREADY_REGISTRATION result_msg = get_msg(error_code, not is_english) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, result_msg) result.set_error(error_code) return Response(result.get_response(), result.get_code()) user_count = User.objects.filter(mdn=mdn).count() serializer = UserSmsSerializer(data=request_data) if serializer.is_valid(): user_model = serializer.data self.verification_code = '%06d' % random.randint(1, 999999) today = datetime.datetime.today() sms_auth_history = SmsAuthHistory.objects.create( date=today, target_mdn=mdn, verification_code=self.verification_code, has_verified=False) if sms_auth_history is None: result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) sender = SmsSender(user_model.get('mdn'), self.verification_code, is_english) sender.start() cache.set(user_model.get('mdn'), self.verification_code, 70) if user_count >= 1: result.set('member_check', True) else: result.set('member_check', False) else: logger_info.info('Request data invalid') result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) logger_info.info(result.get_response()) return Response(result.get_response(), status=result.get_code())
def get_login_info(self): # MDN quick login login_key = self.login_data['login_key'] login_value = self.login_data['login_value'] # Check SMS authentication url = urlmapper.get_url('USER_SMS_VERIFICATION') payload = {'mdn': login_key, 'verification_code': login_value} response = requests.post(url, json=payload) if response.status_code == code.ARIES_200_SUCCESS: try: user_instance = User.objects.get(mdn=login_key) except Exception as e: print(e) result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, code_msg.get_msg( code.ERROR_1005_USER_ALREADY_REGISTRATION)) result.set_error(code.ERROR_1005_USER_ALREADY_REGISTRATION) logger_error.error( code_msg.get_msg( code.ERROR_1005_USER_ALREADY_REGISTRATION)) return Response(result.get_response(), result.get_code()) else: login_info = UserLoginInfo.objects.filter( user=user_instance).exclude( login_key__icontains='dormant')[0] login_id = login_info.id login_info = UserLoginInfo.objects.filter(id=login_id)[0] result = (login_info, login_key, False) return result else: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, code_msg.get_msg(1003)) result.set_error(code.ERROR_1003_SMS_VERIFICATION_FAILURE) return Response(result.get_response(), result.get_code())
def get(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') # Request data parsing try: open_id = request.META['HTTP_OPEN_ID'] access_token = str( request.META['HTTP_AUTHORIZATION']).split(' ')[1] logger_info.info(open_id + ':' + access_token) except Exception as e: print(e) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid(Token or Open id)') return Response(result.get_response(), result.get_code()) # Get usable coupon count and upcoming order count try: today = date.today() coupon_count = CustomerCoupon.objects.filter( open_id=open_id, status=0, end_date__gte=today).count() upcoming_order_count = Order.objects.filter( open_id=open_id, order_status__lt=3).count() result.set('coupon_count', coupon_count) result.set('upcoming_order_count', upcoming_order_count) return Response(result.get_response(), result.get_code()) except Exception as e: print(e) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) return Response(result.get_response(), result.get_code())
def get_login_info(self): # Wechat Login login_sns_open_id = self.login_data['login_sns_open_id'] login_type = self.login_data['login_type'] if login_type == WECHAT_APPLICATION: # WeChat app login payload = { 'appid': 'wx87010cb61b99206d', 'secret': '21b9cf8d51b704fd244f40b351d7876e', 'code': login_sns_open_id, 'grant_type': 'authorization_code' } else: # WeChat public account login payload = { 'appid': 'wx41b86399fee7a2ec', 'secret': '1b3d5dce9860be7e4fc04847df6a6177', 'code': login_sns_open_id, 'grant_type': 'authorization_code' } response = requests.get(resources.WECHAT_ACCESS_TOKEN_URL, params=payload) response_json = response.json() logger_info.info(response.text) if response_json.get('unionid'): login_sns_open_id = response_json['unionid'] try: login_info = UserLoginInfo.objects.filter( login_sns_open_id=login_sns_open_id)[0] except Exception as e: print(e) wechat_login_data = { 'login_key': response_json['openid'], 'login_value': '', 'login_sns_open_id': login_sns_open_id, 'login_sns_access_token': response_json['access_token'], 'login_sns_refresh_token': response_json['refresh_token'] } sign_up_manager = SignUpManager() result = sign_up_manager.sign_up(WECHAT_APPLICATION, wechat_login_data) else: login_instance = UserLoginInfo.objects.get( login_sns_open_id=login_sns_open_id) login_instance.login_sns_access_token = response_json[ 'access_token'] login_instance.login_sns_refresh_token = response_json[ 'refresh_token'] login_instance.save() result = (login_info, login_sns_open_id, False) return result else: result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, code_msg.get_msg(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)) result.set_error(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL) logger_error.error( code_msg.get_msg(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)) return Response(result.get_response(), result.get_code())
def post(self, request): request_data = request.data logger_info.info(request_data) result = ResultResponse(code.ARIES_200_SUCCESS, 'success') # Operation check try: access_token = str( request.META['HTTP_AUTHORIZATION']).split(' ')[1] url = urlmapper.get_url('ADMIN_VALIDATE') payload = {'access_token': access_token} response = requests.post(url, json=payload) if response.status_code != code.ARIES_200_SUCCESS: result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Token or user not found') return Response(result.get_response(), result.get_code()) except Exception as e: print(e) result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Error : ' + str(e)) return Response(result.get_response(), result.get_code()) try: open_id = request_data['open_id'] news_type = request_data['type'] title = request_data['title'] title_cn = request_data['title_cn'] content = request_data['content'] content_cn = request_data['content_cn'] detail = request_data['detail'] detail_cn = request_data['detail_cn'] user = User.objects.get(open_id=open_id) UserNews.objects.create(user=user, type=news_type, title=title, title_cn=title_cn, content=content, content_cn=content_cn, has_read=False, detail=detail, detail_cn=detail_cn) user_notify_info = UserNotifyInfo.objects.get(user=user) user_notify_info.has_news = True user_notify_info.news_count = F('news_count') + 1 user_notify_info.save() except Exception as e: logger_error.error(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Error : ' + str(e)) return Response(result.get_response(), result.get_code()) return Response(result.get_response(), result.get_code())
def post(self, request): request_data = request.data self.logger_info.info(request_data) try: # Request data validation dada_util.dada_cancel_order_validation(request_data) # Request data parsing order_id = request_data['order_id'] cancel_reason_id = request_data['cancel_reason_id'] # Cancel order request dada_manager = DadaManager(self.logger_info, self.logger_error) cancel_result = dada_manager.cancel_order(order_id, cancel_reason_id) # Read dada detail dada_order_data = dada_manager.update_order_detail(order_id) except DataValidationError as instance: message, err_code = instance.args result = ResultResponse(code.ARIES_400_BAD_REQUEST, message, err_code) except AuthInfoError: result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authentication error') except Exception as e: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) else: result = ResultResponse(code.ARIES_200_SUCCESS, 'success') result.set('deduct_fee', cancel_result['deduct_fee']) result.set('shipping_order_detail', dada_order_data) return Response(result.get_response(), result.get_code())
def get(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') try: access_token = str( request.META['HTTP_AUTHORIZATION']).split(' ')[1] logger_info.info(access_token) user_manager = UserManager() except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Token or user not found') return Response(result.get_response(), result.get_code()) try: user_list = user_manager.get_user_list(request) result.set('total_count', len(user_list)) result.set('search_items', user_list) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Bad request') return Response(result.get_response(), result.get_code())
def post(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') request_data = request.data self.logger_info.info(request_data) dada_manager = DadaManager(self.logger_info, self.logger_error) try: # request data validation dada_util.dada_query_validation(request_data) # Make a new order query_result = dada_manager.order_location_query(request_data) # Select result of query selected_result = { 'orderId': query_result['orderId'], 'statusCode': query_result['statusCode'], 'transporterName': query_result['transporterName'], 'transporterPhone': query_result['transporterPhone'], 'transporterLng': query_result['transporterLng'], 'transporterLat': query_result['transporterLat'], 'createTime': query_result['createTime'], 'acceptTime': query_result['acceptTime'], 'fetchTime': query_result['fetchTime'], 'finishTime': query_result['finishTime'], 'cancelTime': query_result['cancelTime'] } except DataValidationError as instance: message, err_code = instance.args result = ResultResponse(code.ARIES_400_BAD_REQUEST, message, err_code) except AuthInfoError: result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authentication error') except BusinessLogicError as instance: message, err_code, data_set = instance.args result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, message, err_code) result.set_map(data_set) except Exception as e: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) else: result.set_map(selected_result) return Response(result.get_response(), result.get_code())
def post(self, request): request_data = request.data logger_info.info(request_data) result = ResultResponse(code.ARIES_200_SUCCESS, 'success') # Operation check try: access_token = request_data['access_token'] url = urlmapper.get_url('ADMIN_VALIDATE') payload = {'access_token': access_token} response = requests.post(url, json=payload) if response.status_code != code.ARIES_200_SUCCESS: result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Token or user not found') return Response(result.get_response(), result.get_code()) except Exception as e: logger_error.error(str(e)) result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Error : ' + str(e)) return Response(result.get_response(), result.get_code()) try: open_id = request_data['open_id'] address_id = request_data['address_id'] user = User.objects.get(open_id=open_id) serializer = UserSerializer(user) user_data = serializer.data user_info = UserInfo.objects.get(user=user) serializer = UserInfoSerializer(user_info) user_info_data = serializer.data address_manager = AddressManagerV2(logger_info, logger_error) user_address = address_manager.get_address(open_id, address_id) if user_address is None: user_address = '' result.set('user', user_data) result.set('user_info', user_info_data) result.set('user_address', user_address) return Response(result.get_response(), result.get_code()) except Exception as e: logger_error.error(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Error : ' + str(e)) return Response(result.get_response(), result.get_code())
def post(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') request_data = request.data self.logger_info.info(request_data) dada_manager = DadaManager(self.logger_info, self.logger_error) try: # request data validation dada_util.dada_order_add_tip_validation(request_data) order_id = request_data['order_id'] tips = request_data['tips'] city_code = request_data['city_code'] info = request_data['info'] # add order tips dada_manager.add_tip(order_id, tips, city_code, info) # Read dada detail dada_order_data = dada_manager.update_order_detail(order_id) except DataValidationError as instance: message, err_code = instance.args result = ResultResponse(code.ARIES_400_BAD_REQUEST, message, err_code) except AuthInfoError: result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authentication error') except BusinessLogicError as instance: message, err_code, data_set = instance.args result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, message, err_code) result.set_map(data_set) except Exception as e: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) else: result.set('shipping_order_detail', dada_order_data) return Response(result.get_response(), result.get_code())
def get(self, request): # Response object result = ResultResponse(code.ARIES_200_SUCCESS, 'success') # Get access token try: open_id = request.META['HTTP_OPEN_ID'] access_token = str( request.META['HTTP_AUTHORIZATION']).split(' ')[1] page = int(request.GET.get('page')) limit = int(request.GET.get('limit')) logger_info.info(open_id + ':' + access_token) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Token or user not found') return Response(result.get_response(), result.get_code()) # Get user list try: user_list = list() users = User.objects.all() user_count = users.count() paginator = Paginator(users, limit) user_objects = paginator.page(page).object_list serializer = UserSerializer(user_objects, many=True) user_data = serializer.data for user in user_data: user['connection_account'] = json.loads( user['connection_account']) user_list.append(user) result.set('total_count', user_count) result.set('accounts', user_list) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data error') return Response(result.get_response(), result.get_code())
def get(self, request): auth_info = header_parser.parse_authentication(request) language_info = header_parser.parse_language(request.META) event_manager = EventManager(self.logger_info, self.logger_error) try: # Get event manager event_object = event_manager.get_event_status( auth_info, None, language_info[0]) event = event_object['event'] if event['need_auth']: user_util.check_auth_info(auth_info) # Check game play condition event_util.check_play_condition(event, language_info[0]) # Play the game reward_result = event_manager.draw_event(event['id'], language_info[0]) reward_id = reward_result[0] random_number = reward_result[1] # Make the history create_result = event_manager.create_event_history( event['id'], auth_info[0], reward_id, random_number, language_info[0]) # Reward interface to purchase server reward_tuple = create_result[2] event_manager.create_coupon(auth_info[0], reward_tuple.target_id, language_info[0]) # Coupon count increase event_manager.increase_coupon_count(auth_info[0], auth_info[1]) except AuthInfoError as e: result = ResultResponse(code.ARIES_401_UNAUTHORIZED, str(e)) except BusinessLogicError as instance: message, err_code = instance.args result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, message) result.set_error(err_code) except Exception as e: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) else: result = ResultResponse(code.ARIES_200_SUCCESS, 'success') result.set('event_reward', create_result[1]) return Response(result.get_response(), result.get_code())
def get(self, request, user_id): # Response object result = ResultResponse(code.ARIES_200_SUCCESS, 'success') # Get access token try: open_id = request.META['HTTP_OPEN_ID'] access_token = str( request.META['HTTP_AUTHORIZATION']).split(' ')[1] logger_info.info(open_id + ':' + access_token) except Exception as e: logger_error.error(str(e)) result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Token or user not found') return Response(result.get_response(), result.get_code()) # Get User object try: # User data user = User.objects.get(id=user_id) serializer = UserSerializer(user) user_data = serializer.data user_data['connection_account'] = json.loads( user_data['connection_account']) user_open_id = user.open_id addresses = UserAddressInfo.objects.filter(user=user) serializer = UserAddressInformationSerializer(addresses, many=True) address_data = serializer.data address_list = list() for address in address_data: address_list.append(address) headers = {'open-id': user_open_id} response = requests.get(urlmapper.get_url('COUPON_LIST'), headers=headers) if response.status_code == code.ARIES_200_SUCCESS: response_json = response.json() coupons = response_json['coupons'] else: coupons = [] result.set('user', user_data) result.set('addresses', address_list) result.set('coupons', coupons) except ObjectDoesNotExist: logger_info.info('User not found') result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'User not found') except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data error') return Response(result.get_response(), result.get_code())
def get(self, request, product_id): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') has_open_id = False # Get page and limit information page = int(request.GET.get('page', 1)) limit = int(request.GET.get('limit', 5)) open_id = request.META.get('HTTP_OPEN_ID', None) if open_id is not None: has_open_id = True try: url = urlmapper.get_url('PRODUCT') + '/' + str(product_id) response = requests.get(url) response_json = response.json() product = response_json['product'] menu = product['menu'] # Menu type check menu_type = product['type'] menu_id = menu['id'] if menu_type > 10: result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Product index invalid') return Response(result.get_response(), result.get_code()) review_lists = list() review_list = CustomerReview.objects.filter(menu=menu_id, visible=True) review_total_count = review_list.count() paginator = Paginator(review_list, limit) review_objects = paginator.page(page).object_list serializer = CustomerReviewSerializer(review_objects, many=True) review_objects_data = serializer.data for review in review_objects_data: date_str = review['created_date'] review['created_date'] = date_str[:10] if has_open_id and open_id == review['open_id']: review['editable'] = True else: review['editable'] = False del review['menu'] del review['open_id'] del review['visible'] review_lists.append(review) result.set('total_count', review_total_count) result.set('page_size', limit) result.set('customer_reviews', review_lists) except Exception as e: logger_error.error(str(e)) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Paging error') return Response(result.get_response(), code.ARIES_500_INTERNAL_SERVER_ERROR) return Response(result.get_response(), result.get_code())
def get_login_info(self): # QQ Mobile web Login login_sns_open_id = self.login_data['login_sns_open_id'] payload = { 'grant_type': 'authorization_code', 'client_id': '1106290901', 'client_secret': 'WbcNyj80WeBvgoSs', 'code': login_sns_open_id, 'redirect_uri': 'https://api.viastelle.com/users/signin/callback' } response = requests.get(resources.QQ_ACCESS_TOKEN_URL, params=payload) logger_info.info(response.text) res_text = response.text if 'access_token' in res_text: res_json = json.loads(json.dumps(parse_qs(res_text))) qq_access_token = res_json['access_token'][0] qq_exprires_in = res_json['expires_in'][0] qq_refresh_token = res_json['refresh_token'][0] payload = {'access_token': qq_access_token} response = requests.get(resources.QQ_OPEN_ID_URL, params=payload) res_text = response.text logger_info.info(res_text) split_res = res_text.split(' ') json_result = json.loads(split_res[1]) response_openid = json_result['openid'] login_sns_access_token = response_openid login_sns_open_id = login_sns_access_token try: login_info = UserLoginInfo.objects.filter( login_sns_open_id=login_sns_open_id)[0] except Exception as e: print(e) qq_login_data = { 'login_key': login_sns_access_token, 'login_value': '', 'login_sns_open_id': login_sns_access_token, 'login_sns_access_token': qq_access_token, 'login_sns_refresh_token': qq_refresh_token, } sign_up_manager = SignUpManager() result = sign_up_manager.sign_up(QQ_MOBILE, qq_login_data) else: login_instance = UserLoginInfo.objects.get( login_sns_open_id=login_sns_open_id) login_instance.login_sns_access_token = login_sns_access_token login_instance.login_sns_refresh_token = qq_refresh_token login_instance.save() result = (login_info, login_sns_open_id, False) return result else: result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, code_msg.get_msg(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)) result.set_error(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL) return Response(result.get_response(), result.get_code())
def delete(self, request): request_data = request.data result = ResultResponse(code.ARIES_200_SUCCESS, 'success') logger_info.info(request_data) # AUthorization check try: open_id = request.META['HTTP_OPEN_ID'] access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1] url = urlmapper.get_url('TOKEN_VALIDATE') headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token} response = requests.get(url, headers=headers) if response.status_code != 200: raise Exception except Exception as e: print(e) result = ResultResponse(code.ARIES_401_UNAUTHORIZED, get_msg(code.ARIES_401_UNAUTHORIZED)) return Response(result.get_response(), result.get_code()) # Request data parsing try: product_id = request_data['product_id'] order_id = request_data['order_id'] review = CustomerReview.objects.get(open_id=open_id, product_id=product_id, order_id=order_id) # Statics information apply payload = {'menu_id': review.menu, 'prev_rate': review.menu_rate} statics_result = requests.delete(urlmapper.get_url('MENU_STATICS'), json=payload) logger_info.info(statics_result.text) review.delete() return Response(result.get_response(), result.get_code()) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code())
def get(self, request, login_key): verification_code = str(cache.get(login_key)) logger_info.info(login_key + ':' + str(cache.get(login_key))) if len(verification_code) < 6: logger_error.error('Unauthorized') result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'It needs verification') return Response(result.get_response(), result.get_code()) try: cache_data = cache.get(login_key) if cache_data == 'complete': result = ResultResponse(code.ARIES_200_SUCCESS, 'success') else: logger_info.info('verification failed') result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Verification failed') return Response(result.get_response(), result.get_code()) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Verification failed') return Response(result.get_response(), result.get_code()) return Response(result.get_response(), result.get_code())