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)
