def top_level(self, request, api_name=None):
"""This is the same method in the Api model with the execption
of the serializer used. This uses the SafeSerializer.
"""
serializer = SafeSerializer()
available_resources = {}
if api_name is None:
api_name = self.api_name
for name in sorted(self._registry):
available_resources[name] = {
'list_endpoint': self._build_reverse_url("api_dispatch_list", kwargs={
'api_name': api_name,
'resource_name': name,
}),
'schema': self._build_reverse_url("api_get_schema", kwargs={
'api_name': api_name,
'resource_name': name,
}),
}
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources, desired_format, options)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def top_level(self, request, api_name=None):
"""
A view that returns a serialized list of all resources registers
to the ``Api``. Useful for discovery.
"""
serializer = Serializer()
if api_name is None:
api_name = self.api_name
available_resources = dict((name, {
'list_endpoint': self._build_reverse_url("api_dispatch_list", kwargs={
'api_name': api_name,
'resource_name': name,
}),
'schema': self._build_reverse_url("api_get_schema", kwargs={
'api_name': api_name,
'resource_name': name,
}),
}) for name in self._registry.iterkeys())
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources, desired_format, options)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def top_level(request):
available_resources = {}
apitop = reverse('ietf.api.top_level')
for name in sorted([ name for name, api in _api_list if len(api._registry) > 0 ]):
available_resources[name] = {
'list_endpoint': '%s/%s/' % (apitop, name),
}
serializer = Serializer()
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources, desired_format, options)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def top_level(self, request, api_name=None):
serializer = Serializer()
available_resources = {}
if api_name is None:
api_name = self.api_name
for name in sorted(self._registry.keys()):
available_resources[name] = {
'list_endpoint': self._build_reverse_url('api_dispatch_list', kwargs={
'api_name': api_name,
'resource_name': name,
}),
'schema': self._build_reverse_url('api_get_schema', kwargs={
'api_name': api_name,
'resource_name': name,
}),
}
if request.GET.get('include_schemas', False) is not False:
available_resources[name]['schema_detailed'] = self._registry[name].build_schema()
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources, desired_format, options)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def top_level(self, request, api_name=None):
"""
A view that returns a serialized list of all resources registers
to the ``Api``. Useful for discovery.
"""
available_resources = {}
if api_name is None:
api_name = self.api_name
for name in sorted(self._registry.keys()):
available_resources[name] = {
"list_endpoint": self._build_reverse_url(
"api_dispatch_list", kwargs={"api_name": api_name, "resource_name": name}
),
"schema": self._build_reverse_url(
"api_get_schema", kwargs={"api_name": api_name, "resource_name": name}
),
}
desired_format = determine_format(request, self.serializer)
options = {}
if "text/javascript" in desired_format:
callback = request.GET.get("callback", "callback")
if not is_valid_jsonp_callback_value(callback):
raise BadRequest("JSONP callback name is invalid.")
options["callback"] = callback
serialized = self.serializer.serialize(available_resources, desired_format, options)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def error_response(request, error_code=None, message=None, status_code=403, serializer_class=HTMLSerializer, **kwargs):
context = {}
if error_code:
context['error_code'] = error_code
if not message:
message = ERRORS[error_code].format(**kwargs)
if message:
context['error_message'] = message
context.update(kwargs)
serializer = serializer_class()
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(context, desired_format, options)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format), status=status_code)
def create_response(self,
request,
data,
response_class=HttpResponse,
*args,
**kwargs):
if isinstance(data, HttpResponse):
return data
if hasattr(self, '_meta'):
serializer = self._meta.serializer
else:
serializer = self.serializer
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = "{}"
if data:
serialized = serializer.serialize(data, desired_format, options)
return response_class(content=serialized,
content_type=build_content_type(desired_format))
def top_level(request):
available_resources = {}
apitop = reverse('ietf.api.top_level')
for name in sorted([ name for name, api in _api_list if len(api._registry) > 0 ]):
available_resources[name] = {
'list_endpoint': '%s/%s/' % (apitop, name),
}
serializer = Serializer()
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources, desired_format, options)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def top_level(self, request, api_name=None):
"""This is the same method in the Api model with the execption
of the serializer used. This uses the SafeSerializer.
"""
serializer = SafeSerializer()
available_resources = {}
if api_name is None:
api_name = self.api_name
for name in sorted(self._registry.keys()):
available_resources[name] = {
'list_endpoint': self._build_reverse_url("api_dispatch_list", kwargs={
'api_name': api_name,
'resource_name': name,
}),
'schema': self._build_reverse_url("api_get_schema", kwargs={
'api_name': api_name,
'resource_name': name,
}),
}
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources, desired_format, options)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def serialize(self, request, data, format, options=None):
options = options or {}
if 'text/javascript' in format:
# get JSONP callback name. default to "callback"
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
return self.serializer.serialize(data, format, options)
def top_level(self, request, api_name=None):
serializer = PrettyJSONSerializer()
available_resources = {}
if api_name is None:
api_name = self.api_name
def render_resource(name, resource):
dct = {
'apidoc': self._build_reverse_url("api_get_doc", kwargs={
'api_name': api_name,
'resource_name': name,
}),
'relativePath': resource.get_relative_uri(),
'schema': self._build_reverse_url("api_get_schema", kwargs={
'api_name': api_name,
'resource_name': name,
}),
'views': {}
}
for _, viewmeta in resource.viewregistry.get_all():
view_name = viewmeta.name
dct['views'][view_name] = viewmeta.get_template_uri(resource)
if resource.children:
dct['children'] = {}
for child in resource.children:
n = child._meta.resource_name
dct['children'][n] = render_resource(n, child)
return dct
for name, resource in self._registry.items():
if not resource.parent:
available_resources[name] = render_resource(name, resource)
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources, desired_format, options)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def top_level(self, request, api_name=None):
"""
A view that returns a serialized list of all resources registers
to the ``Api``. Useful for discovery.
"""
fullschema = request.GET.get('fullschema', False)
fullschema = string_to_python(fullschema)
available_resources = {}
if api_name is None:
api_name = self.api_name
for name, resource in self._registry.items():
if not fullschema:
schema = self._build_reverse_url("api_get_schema",
kwargs={
'api_name': api_name,
'resource_name': name,
})
else:
schema = resource.build_schema()
available_resources[name] = {
'list_endpoint':
self._build_reverse_url("api_dispatch_list",
kwargs={
'api_name': api_name,
'resource_name': name,
}),
'schema':
schema,
}
desired_format = determine_format(request, self.serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = self.serializer.serialize(available_resources,
desired_format, options)
return HttpResponse(content=serialized,
content_type=build_content_type(desired_format))
def create_response(self, data, request, *args, **kwargs):
desired_format = determine_format(request, self.serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = self.serializer.serialize(data, desired_format, options)
return HttpResponse(content=serialized,
content_type=build_content_type(desired_format))
def serialize(self, request, data, format, options=None):
"""
Given a request, data and a desired format, produces a serialized
version suitable for transfer over the wire.
Mostly a hook, this uses the ``Serializer`` from ``Resource._meta``.
"""
options = options or {}
if 'text/javascript' in format:
# get JSONP callback name. default to "callback"
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
return self._meta.serializer.serialize(data, format, options)
def top_level(self, request, api_name=None):
"""
A view that returns a serialized list of all resources registers
to the ``Api``. Useful for discovery.
"""
serializer = Serializer()
available_resources = {}
if api_name is None:
api_name = self.api_name
kwargs = {}
if not self._accept_header_routing:
kwargs['api_name'] = api_name
for name in sorted(self._registry.keys()):
kwargs['resource_name'] = name
available_resources[name] = {
'list_endpoint':
self._build_reverse_url("api_dispatch_list", kwargs=kwargs),
'schema':
self._build_reverse_url("api_get_schema", kwargs=kwargs),
}
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources, desired_format,
options)
content_type = self._build_content_type(desired_format)
return HttpResponse(content=serialized, content_type=content_type)
def top_level(self, request, api_name=None, **kwargs):
"""
A view that returns a serialized list of all resources registers
to the ``Api``. Useful for discovery.
"""
# TODO: Limit visibility of API to valid site IDs only.
# TODO: Potentially, we could only give pieces of the API out based on site ID.
serializer = Serializer()
available_resources = {}
if api_name is None:
api_name = self.api_name
for name in sorted(self._registry.keys()):
kw_bru = {
'api_name': api_name,
'resource_name': name,
}
kw_bru.update(self._registry[name].api_additional_parameters())
kw_bru.update(kwargs)
available_resources[name] = {
'list_endpoint': self._build_reverse_url("api_dispatch_list", kwargs=kw_bru),
'schema': self._build_reverse_url("api_get_schema", kwargs=kw_bru),
}
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources, desired_format, options)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def top_level(self, request, api_name=None):
"""
Overriding top_level method to serialize only resources
that user has rights to use.
"""
serializer = Serializer()
available_resources = {}
if api_name is None:
api_name = self.api_name
for resource_name in sorted(self._registry.keys()):
available_resources[resource_name] = {
'list_endpoint': self._build_reverse_url("api_dispatch_list", kwargs={
'api_name': api_name,
'resource_name': resource_name,
}),
'schema': self._build_reverse_url("api_get_schema", kwargs={
'api_name': api_name,
'resource_name': resource_name,
}),
}
if not available_resources:
return HttpResponseForbidden()
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources, desired_format, options)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def top_level(self, request, api_name=None):
"""
this is a copy/past of the method Api.top_level
the original method locally use a Serializer object which didn't
implement the `to_html` method
this function does exactly the same except it can server html content
"""
serializer = Serializer()
available_resources = {}
if api_name is None:
api_name = self.api_name
for name in sorted(self._registry.keys()):
kwargs = {
'api_name': api_name,
'resource_name': name,
}
available_resources[name] = {
'list_endpoint':
self._build_reverse_url("api_dispatch_list", kwargs=kwargs),
'schema':
self._build_reverse_url("api_get_schema", kwargs=kwargs),
}
desired_format = determine_format(request, serializer)
options = {}
if 'text/html' in desired_format:
serialized = textwrap.dedent("""
<!DOCTYPE html>
<html>
<head>
<style>
body {
font-family: Monaco,"DejaVu Sans Mono",
"Courier New",monospace;
}
div {
margin: 5px;
padding: 5px;
border: 1px solid #444;
border-radius: 5px;
background-color: #eee;
}
h1 {
font-size: 1.4rem;
}
.command:before {
font-size: 1.4rem;
}
</style>
</head>
<title>Api route</title>
<body>
<div>
<h1 class="command">Available route</h1>
<pre>%s</pre>
</div>
</body>
</html>
""") % json.dumps(available_resources, indent=4, sort_keys=True)
else:
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources,
desired_format, options)
return HttpResponse(content=serialized,
content_type=build_content_type(desired_format))
def batch(self, request, api_name=None):
"""
Make batch requests to the api.
"""
# assert False, request
if not request.method.lower() == 'post':
raise Http404
if api_name is None:
api_name = self.api_name
desired_format = determine_format(request, self.serializer)
try:
batch_requests = self.serializer.deserialize(
request.body, desired_format)[:BATCH_API_MAX_REQUESTS]
except ValueError:
raise BadRequest('Bad data.')
if not isinstance(batch_requests, list):
raise BadRequest('Bad structure.')
responses = []
if not request.session.exists(request.session.session_key):
request.session.create()
# assert False, request.session.session_key
self.client.cookies[settings.SESSION_COOKIE_NAME] = \
request.session.session_key
for req in batch_requests:
path = req.get('path')
params = {}
params.update(req.get('params', {}))
response_obj = {
'path': urllib.quote(path),
'params': params,
}
valid_path = re.search(self.prefix, path)
if valid_path:
try:
setattr(self, '_client', Client(**request.META))
response = self.client.get(req['path'], params)
# assert False, dir(response)
response_obj['status'] = response.status_code
response_obj['body'] = response.content
response_obj['headers'] = response._headers
response_obj['cookies'] = response.cookies
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
response_obj['error'] = {
'exc_type': exc_type,
'exc_value': exc_value
}
if settings.DEBUG:
response_obj['exc_traceback'] = traceback.format_exc(
exc_traceback)
else:
# response_obj['status'] = 404
response_obj['error'] = 'Unknown resource uri.',
responses.append(response_obj)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = self.serializer.serialize(
responses, desired_format, options)
return HttpResponse(
content=serialized, content_type=build_content_type(
desired_format))
def top_level(self, request, api_name=None):
"""
this is a copy/past of the method Api.top_level
the original method locally use a Serializer object which didn't
implement the `to_html` method
this function does exactly the same except it can server html content
"""
serializer = Serializer()
available_resources = {}
if api_name is None:
api_name = self.api_name
for name in sorted(self._registry.keys()):
kwargs = {
'api_name': api_name,
'resource_name': name,
}
available_resources[name] = {
'list_endpoint': self._build_reverse_url("api_dispatch_list",
kwargs=kwargs),
'schema': self._build_reverse_url("api_get_schema",
kwargs=kwargs),
}
desired_format = determine_format(request, serializer)
options = {}
if 'text/html' in desired_format:
serialized = textwrap.dedent("""
<!DOCTYPE html>
<html>
<head>
<style>
body {
font-family: Monaco,"DejaVu Sans Mono",
"Courier New",monospace;
}
div {
margin: 5px;
padding: 5px;
border: 1px solid #444;
border-radius: 5px;
background-color: #eee;
}
h1 {
font-size: 1.4rem;
}
.command:before {
font-size: 1.4rem;
}
</style>
</head>
<title>Api route</title>
<body>
<div>
<h1 class="command">Available route</h1>
<pre>%s</pre>
</div>
</body>
</html>
""") % json.dumps(available_resources, indent=4, sort_keys=True)
else:
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources,
desired_format, options)
return HttpResponse(content=serialized,
content_type=build_content_type(desired_format))
