def delete_resource(url): """ Issue a DELETE request to R25 :param url: endpoint to DELETE :return: the response as an lxml.etree """ instance = R25_DAO().get_service_setting("INSTANCE") if instance is not None: url = "/r25ws/wrd/%s/run/%s" % (instance, url) else: url = "/r25ws/servlet/wrd/run/%s" % url headers = { "Accept": "text/xml", "Content-Type": "text/xml", } response = R25_DAO().deleteURL(url, headers) if response.status != 200: raise DataFailureException(url, response.status, response.data) tree = etree.fromstring(response.data.strip()) # XHTML response is an error response xhtml = tree.xpath("//xhtml:html", namespaces=nsmap) if len(xhtml): raise DataFailureException(url, 500, response.data) return tree
def post_resource(url): """ Issue a POST request to R25 :param url: endpoint to POST to :return: the response as an lxml.etree """ instance = R25_DAO().get_service_setting("INSTANCE") if instance is not None: url = "/r25ws/wrd/%s/run/%s" % (instance, url) else: url = "/r25ws/servlet/wrd/run/%s" % url response = R25_DAO().postURL(url, {"Accept": "text/xml"}) if response.status == 429: raise TooManyRequestsException(url) if response.status != 201: raise DataFailureException(url, response.status, response.data) tree = etree.fromstring(response.data.strip()) # XHTML response is an error response xhtml = tree.xpath("//xhtml:html", namespaces=nsmap) if len(xhtml): raise DataFailureException(url, 500, response.data) return tree
def put_resource(url, body): """ Issue a PUT request to R25 :param url: endpoint to PUT to :param body: text to PUT :return: the response as an lxml.etree """ instance = R25_DAO().get_service_setting("INSTANCE") if instance is not None: url = "/r25ws/wrd/%s/run/%s" % (instance, url) else: url = "/r25ws/servlet/wrd/run/%s" % url headers = { "Accept": "text/xml", "Content-Type": "text/xml", } response = R25_DAO().putURL(url, headers, body) if response.status not in (200, 201, 400, 403): raise DataFailureException(url, response.status, response.data) tree = etree.fromstring(response.data.strip()) # XHTML response is an error response xhtml = tree.xpath("//xhtml:html", namespaces=nsmap) if len(xhtml): raise DataFailureException(url, 500, response.data) enodes = tree.xpath("r25:error", namespaces=nsmap) if len(enodes): err = node_as_dict(enodes[0]) raise R25ErrorException(**err) mnodes = tree.xpath("r25:messages", namespaces=nsmap) if len(mnodes): next_ex = None for mnode in reversed(mnodes): next_ex = R25MessageException( mnode.xpath("r25:msg_num", namespaces=nsmap)[0].text, mnode.xpath("r25:msg_id", namespaces=nsmap)[0].text, mnode.xpath("r25:msg_text", namespaces=nsmap)[0].text, mnode.xpath("r25:msg_entity_name", namespaces=nsmap)[0].text, mnode.xpath("r25:msg_object_id", namespaces=nsmap)[0].text, next_ex, ) raise next_ex return tree
def get_calendar_by_name(calendar_name): url = "/calendars/{0}.ics".format(calendar_name) response = TrumbaCalendar.getURL(url) if response.status != 200: raise DataFailureException(url, response.status, str(response.data)) try: calendar = Calendar.from_ical(response.data) except Exception as ex: # turn data errors (ie, UnicodeEncodeError) into # DataFailureException raise DataFailureException(url, 503, ex) return calendar
def _process_resp(request_id, response, is_success_func): """ :param request_id: campus url identifying the request :param response: the GET method response object :param is_success_func: the name of the function for verifying a success code :return: True if successful, False otherwise. raise DataFailureException or a corresponding TrumbaException if the request failed or an error code has been returned. """ if response.status != 200: raise DataFailureException(request_id, response.status, response.reason ) if response.data is None: raise NoDataReturned(request_id, 200) root = objectify.fromstring(response.data) if (root.ResponseMessage is None or root.ResponseMessage.attrib['Code'] is None): raise UnknownError(request_id, 200) resp_code = int(root.ResponseMessage.attrib['Code']) func = partial(is_success_func) if func(resp_code): return True _check_err(resp_code, request_id)
def _get_resource_url(self, url, auto_page, data_key): """ Canvas GET method on a full url. Return representation of the requested resource, chasing pagination links to coalesce resources if indicated. """ headers = {'Accept': 'application/json', 'Connection': 'keep-alive'} response = DAO.getURL(url, headers) if response.status != 200: raise DataFailureException(url, response.status, response.data) data = json.loads(response.data) self.next_page_url = self._next_page(response) if auto_page and self.next_page_url: if isinstance(data, list): data.extend( self._get_resource_url(self.next_page_url, True, data_key)) elif isinstance(data, dict) and data_key is not None: data[data_key].extend( self._get_resource_url(self.next_page_url, True, data_key)[data_key]) return data
def _get_report_file(self, url): response = CanvasFileDownload_DAO().getURL(url) if response.status != 200: raise DataFailureException(url, response.status, response.data) return response.data.decode("utf-8")
def post_image(self, spot_id, image): url = "api/v1/spot/%s/image" % spot_id implementation = Spotseeker_DAO().get_implementation() if implementation.is_mock(): response = Spotseeker_DAO().putURL(url, {}) content = response.data return content else: try: headers = {"X-OAuth-User": settings.OAUTH_USER} auth = OAuth1(settings.SPOTSEEKER_OAUTH_KEY, settings.SPOTSEEKER_OAUTH_SECRET) full_url = settings.RESTCLIENTS_SPOTSEEKER_HOST + "/" + url files = {'image': ('image.jpg', image)} response = requests.post(full_url, files=files, auth=auth, headers=headers) if response.status_code != 201: raise DataFailureException(url, response.status_code, response.content) except AttributeError: raise NotConfigured("must set OAUTH_ keys in settings")
def __init__(self, *args, **kwargs): super(Panopto_DAO, self).__init__(*args, **kwargs) global panopto_dao_access_token if self.get_implementation().is_mock(): return if (not panopto_dao_access_token or ((datetime.utcnow() - panopto_dao_access_token["fetched"]).seconds) >= panopto_dao_access_token["expires_in"]): url = "{}/Panopto/oauth2/connect/token".format( self.get_service_setting('HOST')) headers = { 'Content-Type': 'application/x-www-form-urlencoded', 'Authorization': "Basic {}".format(self.get_service_setting('AUTH_TOKEN')) } body = "grant_type=client_credentials&scope=api" response = self.postURL(url, headers, body) if response.status == 200: panopto_dao_access_token = json.loads(response.data) panopto_dao_access_token["fetched"] = datetime.utcnow() else: raise DataFailureException( url, response.status, json.loads(response.data)["error"] if (response.status == 400) else "Cannot get access token") self.access_token = panopto_dao_access_token
def _raise_exception(req_data, url, response): if response.status == 404: logger.warning(" {0} ===> {1}".format(req_data, response.status)) else: logger.error(" {0} ===> {1}, {2}".format(req_data, response.status, response.data)) raise DataFailureException(url, response.status, response.data)
def _delete_resource(self, url): response = self.DAO.deleteURL(url, self._headers()) if response.status != 200: self._log_error(url, response) raise DataFailureException(url, response.status, response.data) return json.loads(response.data)
def attempt_open_query_permutations(url, orig_file_path, is_header_file): """ Attempt to open a given mock data file with different permutations of the query parameters """ directory = dirname(convert_to_platform_safe(orig_file_path)) + "/" # get all filenames in directory try: filenames = [ f for f in os.listdir(directory) if isfile(join(directory, f)) ] except OSError: return # ensure that there are not extra parameters on any files if is_header_file: filenames = [f for f in filenames if ".http-headers" in f] filenames = [ f for f in filenames if _compare_file_name(orig_file_path + ".http-headers", directory, f) ] else: filenames = [f for f in filenames if ".http-headers" not in f] filenames = [ f for f in filenames if _compare_file_name(orig_file_path, directory, f) ] url_parts = url.split("/") url_parts = url_parts[len(url_parts) - 1].split("?") base = url_parts[0] params = url_parts[1] params = params.split("&") # check to ensure that the base url matches filenames = [f for f in filenames if f.startswith(base)] params = [convert_to_platform_safe(unquote(p)) for p in params] # ensure that all parameters are there for param in params: filenames = [f for f in filenames if param in f] # if we only have one file, return it if len(filenames) == 1: path = join(directory, filenames[0]) return open_file(path) # if there is more than one file, raise an exception if len(filenames) > 1: raise DataFailureException( url, "Multiple mock data files matched the " + "parameters provided!", 404)
def post_resource(url, body): response = Panopto_DAO().postURL(url, {'Accept': 'application/json'}, body) logger.debug("{0} ==POST status==> {1}".format(url, response.status)) if response.status != 200: raise DataFailureException(url, response.status, response.data) logger.debug("{0} ==POST data==> {1}".format(url, response.data)) return response.data
def _get_resource(self, url, headers={}): headers["Accept"] = "application/json" response = KWS_DAO().getURL(url, headers) if response.status != 200: raise DataFailureException(url, response.status, response.data) return json.loads(response.data)
def get_spot_by_id(self, spot_id): self._validate_spotid(spot_id) url = "/api/v1/spot/%s" % spot_id response = Spotseeker_DAO().getURL(url) if response.status != 200: raise DataFailureException(url, response.status, response.data) return self._spot_from_data(json.loads(response.data.decode('utf-8')))
def _post_resource(self, url, request): response = self.DAO.postURL(url, self._post_headers(), body=json.dumps(request)) if response.status not in [200, 201]: self._log_error(url, response) raise DataFailureException(url, response.status, response.data) return json.loads(response.data)
def delete_resource(url): response = Panopto_DAO().deleteURL(url, {'Accept': 'application/json'}) logger.debug("{0} ==DELETE status==> {1}".format(url, response.status)) if response.status != 200: raise DataFailureException(url, response.status, response.data) logger.debug("{0} ==DELETE data==> {1}".format(url, response.data)) return response.data
def get_resource(url): response = Mailman_DAO().getURL(url, {'Accept': 'application/json'}) logger.debug("GET {} ==status==> {}".format(url, response.status)) response_data = str(response.data) if response.status != 200: raise DataFailureException(url, response.status, response_data) logger.debug("GET {} ==data==> {}".format(url, response_data)) return response.data
def load_json(request_id, post_response): if post_response.status != 200: raise DataFailureException(request_id, post_response.status, post_response.reason) if post_response.data is None: raise NoDataReturned(request_id, 200) data = json.loads(post_response.data) _check_err(data, request_id) return data
def get_building_list(self, campus, app_type=None): url = "/api/v1/buildings?extended_info:campus=" + campus if app_type: url += "&extended_info:app_type=" + app_type response = Spotseeker_DAO().getURL(url) if response.status != 200: raise DataFailureException(url, response.status, response.data) return json.loads(response.data.decode('utf-8'))
def all_spots(self): url = "/api/v1/spot/all" response = Spotseeker_DAO().getURL(url) if response.status != 200: raise DataFailureException(url, response.status, response.data) results = json.loads(response.data.decode('utf-8')) spots = self._spots_from_data(results) return spots
def _post_resource(self, url, headers, body): headers.update({ "Accept": "application/json", "Connection": "keep-alive" }) response = Canvas_DAO().postURL(url, headers, body) if not (response.status == 200 or response.status == 204): raise DataFailureException(url, response.status, response.data) return json.loads(response.data)
def _put_resource(self, url, headers, body={}): headers["Content-Type"] = "application/json" headers.update(self._headers()) response = self.DAO.putURL(url, headers, json.dumps(body)) if response.status != 200 and response.status != 201: self._log_error(url, response) raise DataFailureException(url, response.status, response.data) return json.loads(response.data)
def search_spots(self, query_tuple): """ Returns a list of spots matching the passed parameters """ url = "/api/v1/spot?" + urlencode(query_tuple) response = Spotseeker_DAO().getURL(url) if response.status != 200: raise DataFailureException(url, response.status, response.data) results = json.loads(response.data.decode('utf-8')) return self._spots_from_data(results)
def _delete_resource(self, url): """ Canvas DELETE method. """ params = {} self._set_as_user(params) headers = {'Accept': 'application/json', 'Connection': 'keep-alive'} url = url + self._params(params) response = DAO.deleteURL(url, headers) if not (response.status == 200 or response.status == 204): raise DataFailureException(url, response.status, response.data) return response
def get_resource(url): """ Issue a GET request to R25 with the given url and return a response as an etree element. """ instance = R25_DAO().get_service_setting('INSTANCE') if instance is not None: url = "/r25ws/wrd/%s/run/%s" % (instance, url) else: url = "/r25ws/servlet/wrd/run/%s" % url response = R25_DAO().getURL(url, {"Accept": "text/xml"}) if response.status != 200: raise DataFailureException(url, response.status, response.data) tree = etree.fromstring(response.data.strip()) # XHTML response is an error response xhtml = tree.xpath("//xhtml:html", namespaces=nsmap) if len(xhtml): raise DataFailureException(url, 500, response.data) return tree
def _post_resource(self, url, body): """ Canvas POST method. """ params = {} self._set_as_user(params) headers = {'Content-Type': 'application/json', 'Accept': 'application/json', 'Connection': 'keep-alive'} url = url + self._params(params) response = DAO.postURL(url, headers, json.dumps(body)) if not (response.status == 200 or response.status == 204): raise DataFailureException(url, response.status, response.data) return json.loads(response.data)
def validate_logins(logins=[]): url = '/api/v1/logins' headers = { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Connection': 'keep-alive' } body = {'logins': logins} response = SIS_PROVISIONER_DAO().postURL(url, headers, json.dumps(body)) if response.status != 200: raise DataFailureException(url, response.status, response.data) data = json.loads(response.data) return data.get('users')
def delete_item_image(self, item_id, image_id, etag): url = "/api/v1/item/%s/image/%s" % (item_id, image_id) implementation = Spotseeker_DAO().get_implementation() if implementation.is_mock(): response = mock.Mock() response.status = 200 else: try: headers = { "X-OAuth-User": settings.OAUTH_USER, "If-Match": etag } response = Spotseeker_DAO().deleteURL(url, headers) content = response.data except AttributeError: raise NotConfigured("Must set OAUTH_USER in settings") if response.status != 200: raise DataFailureException(url, response.status, content)
def is_member(self, group_id, netid, is_effective): self._valid_group_id(group_id) # GWS doesn't accept EPPNs on effective member checks, for UW users netid = re.sub('@washington.edu', '', netid) url = "{}/group/{}/{}/{}".format( self.API, group_id, "effective_member" if is_effective else "member", netid) # Not using _get_resource() here because it automatically logs 404s response = self.DAO.getURL(url, self._headers()) if response.status == 200: return True elif response.status == 404: return False else: self._log_error(url, response) raise DataFailureException(url, response.status, response.data)