def test_build_content_type(self):
self.assertEqual(build_content_type('application/json'),
'application/json; charset=utf-8')
self.assertEqual(build_content_type('application/xml'),
'application/xml; charset=utf-8')
self.assertEqual(build_content_type('application/json; charset=ascii'),
'application/json; charset=ascii')
def create_response(self,
request,
data,
response_class=HttpResponse,
**response_kwargs):
"""
Extracts the common "which-format/serialize/return-response" cycle.
Mostly a useful shortcut/hook.
"""
desired_format = self.determine_format(request)
if desired_format in ('chemical/x-mdl-sdfile', 'text/csv'):
if desired_format == 'chemical/x-mdl-sdfile':
streaming_content = self.sdf_response_generator(data)
filename = "result.sdf"
else:
streaming_content = self.csv_response_generator(data, request)
filename = "result.csv"
response = StreamingHttpResponse(
streaming_content=streaming_content,
content_type=build_content_type(desired_format),
**response_kwargs)
response[
'Content-Disposition'] = 'attachment; filename="%s"' % filename
return response
serialized = self.serialize(request, data, desired_format)
return response_class(content=serialized,
content_type=build_content_type(desired_format),
**response_kwargs)
def test_build_content_type(self):
# JSON & JSONP don't include charset.
self.assertEqual(build_content_type('application/json'), 'application/json')
self.assertEqual(build_content_type('text/javascript'), 'text/javascript')
self.assertEqual(build_content_type('application/json', encoding='ascii'), 'application/json')
# Everything else should.
self.assertEqual(build_content_type('application/xml'), 'application/xml; charset=utf-8')
self.assertEqual(build_content_type('application/xml', encoding='ascii'), 'application/xml; charset=ascii')
def test_build_content_type(self):
# JSON & JSONP don't include charset.
self.assertEqual(build_content_type('application/json'), 'application/json')
self.assertEqual(build_content_type('text/javascript'), 'text/javascript')
self.assertEqual(build_content_type('application/json', encoding='ascii'), 'application/json')
# Everything else should.
self.assertEqual(build_content_type('application/xml'), 'application/xml; charset=utf-8')
self.assertEqual(build_content_type('application/xml', encoding='ascii'), 'application/xml; charset=ascii')
def wrapper(request, *args, **kwargs):
try:
desired_format = self.determine_format(request)
if method == "POST" or method == "PUT":
if not raw:
data = self.deserialize(request, request.raw_post_data,
desired_format)
else:
data = request.raw_post_data
elif method == "GET":
data = request.GET
response_data = {}
if hasattr(form_class, "static_get_form_kwargs"):
kwargs = form_class.static_get_form_kwargs(
request, data, *args, **kwargs)
form = form_class(**kwargs)
else:
form = form_class(data=data)
if not form.is_valid():
context = RequestContext(request, {})
context['form'] = form
errors = dict([(k, form.error_class.as_text(v))
for k, v in form.errors.items()])
response_data['errors'] = errors
serialized = self.serialize(request, response_data,
desired_format)
return http.HttpBadRequest(
serialized,
content_type=build_content_type(desired_format))
else:
if hasattr(form, "save"):
obj = form.save()
if obj:
if hasattr(form, "bundle_obj"):
response_data = form.bundle_obj(obj, request)
else:
response_data = obj
return self.create_response(request, response_data)
except JSONDecodeError, e:
data = dict(errors=e.message)
serialized = self.serialize(request, data, desired_format)
return http.HttpBadRequest(
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 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,
**response_kwargs):
"""
***
Override:
- check format for csv and change content-disposition as appropriate.
***
Extracts the common "which-format/serialize/return-response" cycle.
Mostly a useful shortcut/hook.
"""
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
response = response_class(
content=serialized,
content_type=build_content_type(desired_format),
**response_kwargs)
if desired_format is self._meta.serializer.content_types['csv']:
get_dict = request.GET.dict()
get_dict.pop('format')
get_dict.pop('apikey')
arg_str = '__'.join(['_'.join(g) for g in get_dict.items()])
if arg_str:
fname = '{0}__{1}'.format(API_OUTFILE_PREFIX, arg_str)[:252]
else:
fname = API_OUTFILE_PREFIX
response[
'Content-Disposition'] = 'attachment; filename="{0}.csv"'.format(
fname)
return response
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 create_response(self,
request,
data,
response_class=HttpResponse,
response_objects=None,
**response_kwargs):
"""
Extracts the common "which-format/serialize/return-response" cycle.
Mostly a useful shortcut/hook.
"""
# If an user does not have at least view permissions, he won't be able to see the resource at all.
filtered_objects_ids = None
if response_objects:
filtered_objects_ids = [
item.id for item in response_objects if request.user.has_perm(
'view_resourcebase', item.get_self_resource())
]
if isinstance(data, dict) and 'objects' in data and not isinstance(
data['objects'], list):
if filtered_objects_ids:
data['objects'] = [
x for x in list(self.format_objects(data['objects']))
if x['id'] in filtered_objects_ids
]
else:
data['objects'] = list(self.format_objects(data['objects']))
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
return response_class(content=serialized,
content_type=build_content_type(desired_format),
**response_kwargs)
def post_saved_shows(self, request, **kwargs):
LOG.debug('in saved show')
form = SavedShowsForm(request.POST)
if form.is_valid():
user = request.user
add, remove = form.cleaned_data['add'], form.cleaned_data['remove']
LOG.debug('Request by user: %s to add: %s, remove: %s' % (user, add, remove))
show_set = user.starred_show_set
if add and add.id:
show_set.add_shows([add])
if remove and remove.id:
show_set.remove_shows([remove])
if add or remove:
show_set.save()
else:
desired_format = self.determine_format(request)
serialized = self.serialize(request, form.errors, desired_format)
response = HttpBadRequest(content=serialized, content_type=build_content_type(desired_format))
raise ImmediateHttpResponse(response=response)
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 create_response(self, request, data, response_class=HttpResponse, **response_kwargs):
"""
Ensure that data is returned in the right format as an attachment if returning SDF or XLSX data
Should an object have been created or updated, now is the time to
reindex it in the elasticsearch index
"""
desired_format = self.determine_format(request)
if response_class == http.HttpCreated or response_class == http.HttpAccepted:
batches = []
if data.data.get("objects"):
for b in data.data.get("objects"):
batches.append(b.obj)
else:
batches.append(data.obj)
try:
index_batches_in_new_index(batches)
except:
#There has been an error in indexing therefore cleanup
session_key = request.COOKIES[settings.SESSION_COOKIE_NAME]
clean_up_multi_batch(data.obj.multiple_batch, session_key)
raise
serialized = self.serialize(request, data, desired_format)
rc = response_class(content=serialized, content_type=build_content_type(
desired_format), **response_kwargs)
if(desired_format == 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'):
rc['Content-Disposition'] = 'attachment; filename=export_from_chembiohub_chemreg%d.xlsx' % int(time.time())
elif(desired_format == 'chemical/x-mdl-sdfile'):
rc['Content-Disposition'] = 'attachment; filename=export_from_chembiohub_chemreg%d.sdf' % int(time.time())
return rc
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
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)
serialized = serializer.serialize(available_resources, desired_format)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def raise_bad_request(self, bundle, errors):
desired_format = self.determine_format(bundle.request)
serialized = self.serialize(bundle.request, errors, desired_format)
response = http.HttpBadRequest(
content=serialized,
content_type=build_content_type(desired_format))
raise ImmediateHttpResponse(response=response)
def post_list(self, request, **kwargs):
form = ItemImageCreationForm(data=request.POST,
files=request.FILES)
if form.is_valid():
if form.instance.item.store != request.user.store:
raise ImmediateHttpResponse(response=http.HttpForbidden())
images = form.save()
to_be_serialized = []
for image in images:
bundle = self.build_bundle(obj=image, request=request)
bundle = self.full_dehydrate(bundle)
to_be_serialized.append(bundle)
response = self.create_response(request, to_be_serialized)
response['x-frame-options'] = 'SAMEORIGIN'
return response
else:
desired_format = self.determine_format(request)
serialized = self.serialize(request,
{'errors': form.errors },
desired_format)
response = http.HttpBadRequest(
content=serialized,
content_type=build_content_type(desired_format))
response['x-frame-options'] = 'SAMEORIGIN'
raise ImmediateHttpResponse(response=response)
def build_response(self):
from tastypie.serializers import Serializer
serializer = Serializer()
return HttpResponse(
content=serializer.serialize(self.response_data),
content_type=build_content_type('application/json')
)
def create_response(self,
request,
data,
response_class=HttpResponse,
**response_kwargs):
"""
THis is overridden from tastypie. The point here is to be able to
Set the content-disposition header for csv downloads. That is the only
instance in which this override should change the response is if the
desired format is csv.
The content-disposition header allows the user to save the .csv
to a directory of their chosing.
"""
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
response = response_class(
content=serialized,
content_type=build_content_type(desired_format),
**response_kwargs)
if desired_format == 'text/csv':
response[
'Content-Disposition'] = 'attachment; filename=polio_data.csv'
return response
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 DAS_sources in registers.
"""
sources = self._registry
if request.GET:
form = DASSourcesForm(request.GET)
if form.is_valid():
version = form.cleaned_data['version']
capability = form.cleaned_data['capability']
authority = form.cleaned_data['authority']
stype = form.cleaned_data['type']
organism = form.cleaned_data['organism']
else:
# :TODO raise exception
pass
sources = dict((key, value) for key, value in sources.items() if \
value._meta.version == int(version))
else: pass
if api_name is None:
api_name = self.api_name
#desired_format = determine_format(request, serializer)
desired_format = 'application/xml'
options = {}
response = HttpResponse(content = top_level_serializer(sources),
content_type=build_content_type(desired_format))
response = add_das_headers(response, self.version)
return response
def is_valid(self, bundle, request=None):
"""Overridden to perform validation and persistence in one step"""
files = {}
# FIXME avatar file translation and persistence
avatar_data = bundle.data.get('avatar')
if avatar_data:
try:
files['avatar'] = SimpleUploadedFile(
avatar_data['name'], base64.b64decode(avatar_data['file']),
avatar_data.get("content_type", "application/octet-stream")
)
except Exception:
raise ImmediateHttpResponse(HttpBadRequest(content='ERROR PROCESSING IMAGE'))
# instantiate and validate the form
form = self._meta.validation.form_class(data=bundle.data, files=files)
if form.is_valid():
user = form.save()
# update request with the new user
request.user = user
request.user_created = True
# error handling
else:
if request:
desired_format = self.determine_format(request)
else:
desired_format = self._meta.default_format
serialized = self.serialize(request, form.errors, desired_format)
response = HttpBadRequest(content=serialized, content_type=build_content_type(desired_format))
raise ImmediateHttpResponse(response=response)
def create_response(self,
request,
data,
response_class=HttpResponse,
**response_kwargs):
"""
Extracts the common "which-format/serialize/return-response" cycle.
Mostly a useful shortcut/hook.
"""
VALUES = [
# fields in the db
'id',
'uuid',
'title',
'date',
'abstract',
'csw_wkt_geometry',
'csw_type',
'distribution_description',
'distribution_url',
'owner__username',
'share_count',
'popular_count',
'srid',
'category__gn_description',
'supplemental_information',
'thumbnail_url',
'detail_url',
'rating',
]
if '/documents/' in request.path:
VALUES.append('papersize')
VALUES.append('version')
VALUES.append('datasource')
VALUES.append('subtitle')
if isinstance(data, dict) and 'objects' in data and not isinstance(
data['objects'], list):
data['objects'] = list(data['objects'].values(*VALUES))
if '/documents/' in request.path:
for row in data['objects']:
location = Document.objects.get(pk=row['id'])
row['region_description'] = ''
row['keyword_description'] = ''
for item in location.regions.all():
row['region_description'] = row[
'region_description'] + ' ' + str(item)
for item in location.keywords.all():
row['keyword_description'] = row[
'keyword_description'] + ' ' + str(item)
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
return response_class(content=serialized,
content_type=build_content_type(desired_format),
**response_kwargs)
def answerBadRequest(self, request, error):
response_class = http.HttpBadRequest
desired_format = self.determine_format(request)
data = {'exception': error}
serialized = self.serialize(request, data, desired_format)
raise ImmediateHttpResponse(response=response_class(content=serialized,
content_type=build_content_type(desired_format)))
def validate_bundle_data(self, bundle, request, dataset):
"""
Perform additional validation that isn't possible with the Validation object.
"""
errors = {}
field_count = len(bundle.data["data"])
if dataset.initial_upload and not dataset.row_count:
errors["dataset"] = [
"Can not create or modify data for a dataset which has initial_upload, but has not completed the import process."
]
if dataset.column_schema is None:
errors["dataset"] = ["Can not create or modify data for a dataset without columns."]
else:
expected_field_count = len(dataset.column_schema)
if field_count != expected_field_count:
errors["data"] = ["Got %i data fields. Expected %i." % (field_count, expected_field_count)]
# Cribbed from is_valid()
if errors:
if request:
desired_format = self.determine_format(request)
else:
desired_format = self._meta.default_format
serialized = self.serialize(request, errors, desired_format)
response = http.HttpBadRequest(content=serialized, content_type=build_content_type(desired_format))
raise ImmediateHttpResponse(response=response)
def create_response(self, request, data, response_class=HttpResponse,
**response_kwargs):
"""
Override the default create_response so we can pass the GET
parameters into options. This allows us to use GET parameters
to adjust how our serializers respond.
:param request: Django request object (Required)
:type request: :class:`django.http.HttpRequest`
:param data: The data to be worked on.
:type data: dict for multiple objects,
:class:`tastypie.bundle.Bundle` for a single object.
:param response_class: The class to utilize for the response.
:type response_class: :class:`django.http.HttpResponse` (Default)
:returns: :class:`django.http.HttpResponse` (Default)
"""
desired_format = self.determine_format(request)
options = request.GET.copy()
options['username'] = request.user.username
serialized = self.serialize(request, data, desired_format,
options=options)
return response_class(content=serialized,
content_type=build_content_type(desired_format),
**response_kwargs)
def login(request, **kwargs):
# self.method_check(request, allowed=['post'])
# self.is_authenticated(request)
# self.throttle_check(request)
developer_key = request.GET.get('developer_key')
username = request.GET.get('username')
password = request.GET.get('password')
if not developer_key or not username or not password:
return HttpUnauthorized()
try:
dev_key = DeveloperApiKey.objects.get(key=developer_key, approved=True)
except DeveloperApiKey.DoesNotExist:
return HttpUnauthorized()
user = authenticate(username=username, password=password)
if user:
try:
key = UserApiKey.objects.get(user=user, developer_key=dev_key)
except UserApiKey.DoesNotExist:
key = UserApiKey(user=user, developer_key=dev_key)
key.save()
# self.log_throttled_access(request)
serializer = Serializer()
desired_format = determine_format(request, serializer)
serialized = serializer.serialize({'key': key.key}, desired_format)
return HttpResponse(content=serialized,
content_type=build_content_type(desired_format))
else:
return HttpUnauthorized()
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 create_response(self, request, data, response_class=HttpResponse, **response_kwargs):
"""
Extracts the common "which-format/serialize/return-response" cycle.
Mostly a useful shortcut/hook.
"""
VALUES = [
# fields in the db
'id',
'uuid',
'title',
'abstract',
'csw_wkt_geometry',
'csw_type',
'distribution_description',
'distribution_url',
'owner_id',
'share_count',
'srid',
'category',
'supplemental_information',
'thumbnail_url',
'detail_url',
'rating',
]
if isinstance(data, dict) and 'objects' in data and not isinstance(data['objects'], list):
data['objects'] = list(data['objects'].values(*VALUES))
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
return response_class(content=serialized, content_type=build_content_type(desired_format), **response_kwargs)
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
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)
serialized = serializer.serialize(available_resources, desired_format)
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 DAS_sources in registers.
"""
sources = self._registry
if request.GET:
form = DASSourcesForm(request.GET)
if form.is_valid():
version = form.cleaned_data['version']
capability = form.cleaned_data['capability']
authority = form.cleaned_data['authority']
stype = form.cleaned_data['type']
organism = form.cleaned_data['organism']
else:
# :TODO raise exception
pass
sources = dict((key, value) for key, value in sources.items() if \
value._meta.version == int(version))
else:
pass
if api_name is None:
api_name = self.api_name
#desired_format = determine_format(request, serializer)
desired_format = 'application/xml'
options = {}
response = HttpResponse(
content=top_level_serializer(sources),
content_type=build_content_type(desired_format))
response = add_das_headers(response, self.version)
return response
def raise_bad_request(self, bundle, errors):
desired_format = self.determine_format(bundle.request)
serialized = self.serialize(bundle.request, errors, desired_format)
response = http.HttpBadRequest(
content=serialized,
content_type=build_content_type(desired_format))
raise ImmediateHttpResponse(response=response)
def _create_response(res, request, data, response_class=HttpResponse, **response_kwargs):
"""
Overrides GeoNode's' own create_response() in BaseResources,
because get_list() may be skipping the dehydrate() call when
there are multiple objects to return.
"""
if isinstance(
data,
dict) and 'objects' in data and not isinstance(
data['objects'],
list):
logger.debug("Adding CREAD info to %d objects", len(data['objects']))
objects = list(data['objects'].values(*RESPONSE_VALUES))
for obj in objects:
_add_category_info(obj['id'], obj)
data['objects'] = objects
logger.debug("Added CREAD info")
desired_format = res.determine_format(request)
serialized = res.serialize(request, data, desired_format)
return response_class(
content=serialized,
content_type=build_content_type(desired_format),
**response_kwargs)
def create_response(self, request, data, response_class=HttpResponse, **response_kwargs):
"""
***
Override:
- check format for csv and change content-disposition as appropriate.
***
Extracts the common "which-format/serialize/return-response" cycle.
Mostly a useful shortcut/hook.
"""
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
response = response_class(content=serialized, content_type=build_content_type(desired_format), **response_kwargs)
if desired_format is self._meta.serializer.content_types['csv']:
get_dict = request.GET.dict()
get_dict.pop('format')
get_dict.pop('apikey')
arg_str = '__'.join(['_'.join(g) for g in get_dict.items()])
if arg_str:
fname = '{0}__{1}'.format(API_OUTFILE_PREFIX, arg_str)[:252]
else:
fname = API_OUTFILE_PREFIX
response['Content-Disposition'] = 'attachment; filename="{0}.csv"'.format(fname)
return response
def login(request, **kwargs):
# self.method_check(request, allowed=['post'])
# self.is_authenticated(request)
# self.throttle_check(request)
developer_key = request.GET.get('developer_key')
username = request.GET.get('username')
password = request.GET.get('password')
if not developer_key or not username or not password:
return HttpUnauthorized()
try:
dev_key = DeveloperApiKey.objects.get(key=developer_key, approved=True)
except DeveloperApiKey.DoesNotExist:
return HttpUnauthorized()
user = authenticate(username=username, password=password)
if user:
try:
key = UserApiKey.objects.get(user=user, developer_key=dev_key)
except UserApiKey.DoesNotExist:
key = UserApiKey(user=user, developer_key=dev_key)
key.save()
# self.log_throttled_access(request)
serializer = Serializer()
desired_format = determine_format(request, serializer)
serialized = serializer.serialize({'key' : key.key}, desired_format)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
else:
return HttpUnauthorized()
def create_response(self, request, data, response_class=HttpResponse, response_objects=None, **response_kwargs):
"""
Extracts the common "which-format/serialize/return-response" cycle.
Mostly a useful shortcut/hook.
"""
# If an user does not have at least view permissions, he won't be able to see the resource at all.
filtered_objects_ids = None
if response_objects:
filtered_objects_ids = [
item.id
for item in response_objects
if request.user.has_perm("view_resourcebase", item.get_self_resource())
]
if isinstance(data, dict) and "objects" in data and not isinstance(data["objects"], list):
if filtered_objects_ids:
data["objects"] = [
x for x in list(self.format_objects(data["objects"])) if x["id"] in filtered_objects_ids
]
else:
data["objects"] = list(self.format_objects(data["objects"]))
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
return response_class(content=serialized, content_type=build_content_type(desired_format), **response_kwargs)
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 create_response(self, request, data, response_class=HttpResponse, **response_kwargs):
"""
Extracts the common "which-format/serialize/return-response" cycle.
Mostly a useful shortcut/hook.
"""
VALUES = [
# fields in the db
"id",
"uuid",
"title",
"date",
"abstract",
"csw_wkt_geometry",
"csw_type",
"owner__username",
"share_count",
"popular_count",
"srid",
"category__gn_description",
"supplemental_information",
"thumbnail_url",
"detail_url",
"rating",
]
if isinstance(data, dict) and "objects" in data and not isinstance(data["objects"], list):
data["objects"] = list(data["objects"].values(*VALUES))
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
return response_class(content=serialized, content_type=build_content_type(desired_format), **response_kwargs)
def _create_response(res,
request,
data,
response_class=HttpResponse,
**response_kwargs):
"""
Overrides GeoNode's' own create_response() in BaseResources,
because get_list() may be skipping the dehydrate() call when
there are multiple objects to return.
"""
if isinstance(data, dict) and 'objects' in data and not isinstance(
data['objects'], list):
logger.debug("Adding CREAD info to %d objects", len(data['objects']))
objects = list(data['objects'].values(*RESPONSE_VALUES))
for obj in objects:
_add_category_info(obj['id'], obj)
data['objects'] = objects
logger.debug("Added CREAD info")
desired_format = res.determine_format(request)
serialized = res.serialize(request, data, desired_format)
return response_class(content=serialized,
content_type=build_content_type(desired_format),
**response_kwargs)
def _handle_500(self, request, exception):
import traceback
import sys
the_trace = '\n'.join(traceback.format_exception(*(sys.exc_info())))
response_class = http.HttpApplicationError
if isinstance(exception, (NotFound, ObjectDoesNotExist)):
response_class = HttpResponseNotFound
if settings.DEBUG:
data = {
"error_message": unicode(exception),
"traceback": the_trace,
}
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
return response_class(content=serialized, content_type=build_content_type(desired_format))
# When DEBUG is False, send an error message to the admins (unless it's
# a 404, in which case we check the setting).
if not isinstance(exception, (NotFound, ObjectDoesNotExist)):
log = logging.getLogger('sentry.errors')
log.error('Internal Server Error: %s' % request.path, exc_info=sys.exc_info(),
extra={'status_code': 500, 'request': request})
if django.VERSION < (1, 3, 0) and getattr(settings, 'SEND_BROKEN_LINK_EMAILS', False):
from django.core.mail import mail_admins
subject = 'Error (%s IP): %s' % (
(request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS and 'internal' or 'EXTERNAL'), request.path)
try:
request_repr = repr(request)
except:
request_repr = "Request repr() unavailable"
message = "%s\n\n%s" % (the_trace, request_repr)
mail_admins(subject, message, fail_silently=True)
# Prep the data going out.
data = {
"exception": getattr(settings, 'TASTYPIE_CANNED_ERROR',
"Sorry, this request could not be processed. Please try again later."),
}
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
return response_class(content=serialized, content_type=build_content_type(desired_format))
def wrap_form(self, form_class, method="POST", raw=False, anon=False):
"""
Creates a view for a given form class, which calls to is_valid()
and save() when needed. You can get the form args reimplementing
static_get_form_kwargs(request, data, *args, **kwargs) in your
form.
"""
@csrf_exempt
def wrapper(request, *args, **kwargs):
if not anon and not request.user.is_authenticated():
self.is_authenticated(request)
try:
desired_format = self.determine_format(request)
if method == "POST" or method== "PUT":
if not raw:
data = self.deserialize(request, request.raw_post_data,
desired_format)
else:
data = request.raw_post_data
elif method == "GET":
data = request.GET
response_data = {}
if hasattr(form_class, "static_get_form_kwargs"):
kwargs = form_class.static_get_form_kwargs(request, data,
*args, **kwargs)
form = form_class(**kwargs)
else:
form = form_class(data=data)
if not form.is_valid():
context = RequestContext(request, {})
context['form'] = form
errors = dict([(k, form.error_class.as_text(v)) for k, v in form.errors.items()])
response_data['errors'] = errors
serialized = self.serialize(request, response_data, desired_format)
return http.HttpBadRequest(serialized,
content_type=build_content_type(desired_format))
else:
if hasattr(form, "save"):
obj = form.save()
if obj:
if hasattr(form, "bundle_obj"):
response_data = form.bundle_obj(obj, request)
else:
response_data = obj
return self.create_response(request, response_data)
except JSONDecodeError, e:
data = dict(errors=e.message)
serialized = self.serialize(request, data, desired_format)
return http.HttpBadRequest(serialized,
content_type=build_content_type(desired_format))
except (BadRequest, fields.ApiFieldError), e:
data = dict(errors=e.args[0])
serialized = self.serialize(request, data, desired_format)
return http.HttpBadRequest(serialized,
content_type=build_content_type(desired_format))
def error_response(self, errors, request):
if request:
desired_format = self.determine_format(request)
else:
desired_format = self._meta.default_format
serialized = self.serialize(request, errors, desired_format)
response = http.HttpBadRequest(content=serialized, content_type=build_content_type(desired_format))
raise ImmediateHttpResponse(response=response)
def wrapper(request, *args, **kwargs):
if not anon and not request.user.is_authenticated():
self.is_authenticated(request)
try:
desired_format = self.determine_format(request)
if method == "POST" or method== "PUT":
if not raw:
data = self.deserialize(request, request.raw_post_data,
desired_format)
else:
data = request.raw_post_data
elif method == "GET":
data = request.GET
response_data = {}
if hasattr(form_class, "static_get_form_kwargs"):
kwargs = form_class.static_get_form_kwargs(request, data,
*args, **kwargs)
form = form_class(**kwargs)
else:
form = form_class(data=data)
if not form.is_valid():
context = RequestContext(request, {})
context['form'] = form
errors = dict([(k, form.error_class.as_text(v)) for k, v in form.errors.items()])
response_data['errors'] = errors
serialized = self.serialize(request, response_data, desired_format)
return http.HttpBadRequest(serialized,
content_type=build_content_type(desired_format))
else:
if hasattr(form, "save"):
obj = form.save()
if obj:
if hasattr(form, "bundle_obj"):
response_data = form.bundle_obj(obj, request)
else:
response_data = obj
return self.create_response(request, response_data)
except JSONDecodeError, e:
data = dict(errors=e.message)
serialized = self.serialize(request, data, desired_format)
return http.HttpBadRequest(serialized,
content_type=build_content_type(desired_format))
def raise_error(self, request, http_method, data):
'''
Shortcut to return an error
'''
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
return http_method(serialized,
content_type=build_content_type(desired_format))
def create_response(self, request, data, response_class=HttpResponse, **response_kwargs):
desired_format = self.determine_format(request)
if isinstance(data, Bundle):
serialized = data.obj
elif isinstance(data, dict):
serialized = [raw.obj for raw in data['objects']]
serialized = {'data':serialized}
return HttpResponse(content=json.dumps(serialized), content_type=build_content_type(desired_format))
def error_response(self, errors, request):
if request:
desired_format = self.determine_format(request)
else:
desired_format = self._meta.default_format
serialized = self.serialize(request, errors, desired_format)
response = http.HttpBadRequest(content=serialized, content_type=build_content_type(desired_format))
raise ImmediateHttpResponse(response=response)
def raise_error(self, request, http_method, data):
'''
Shortcut to return an error
'''
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
return http_method(serialized,
content_type=build_content_type(desired_format))
def custom_response(resource, request, response_klass, response_data):
from tastypie.exceptions import ImmediateHttpResponse
from tastypie.utils.mime import build_content_type
desired_format = resource.determine_format(request)
response = response_klass(content=resource.serialize(
request, response_data, desired_format),
content_type=build_content_type(desired_format))
return ImmediateHttpResponse(response=response)
def _handle_error(self, request, error_message, response_class=http.HttpForbidden):
data = {
"error_message": error_message,
}
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
response = response_class(content=serialized,
content_type=build_content_type(desired_format))
raise ImmediateHttpResponse(response)
def create_response(
self,
request,
data,
response_class=HttpResponse,
response_objects=None,
**response_kwargs):
"""
Extracts the common "which-format/serialize/return-response" cycle.
Mostly a useful shortcut/hook.
"""
VALUES = [
# fields in the db
'id',
'uuid',
'title',
'date',
'abstract',
'csw_wkt_geometry',
'csw_type',
'owner__username',
'share_count',
'popular_count',
'srid',
'category__gn_description',
'supplemental_information',
'thumbnail_url',
'detail_url',
'rating',
]
# If an user does not have at least view permissions, he won't be able to see the resource at all.
filtered_objects_ids = None
if response_objects:
filtered_objects_ids = [item.id for item in response_objects if
request.user.has_perm('view_resourcebase', item.get_self_resource())]
if isinstance(
data,
dict) and 'objects' in data and not isinstance(
data['objects'],
list):
if filtered_objects_ids:
data['objects'] = [x for x in list(data['objects'].values(*VALUES)) if x['id'] in filtered_objects_ids]
else:
data['objects'] = list(data['objects'].values(*VALUES))
desired_format = self.determine_format(request)
serialized = self.serialize(request, data, desired_format)
return response_class(
content=serialized,
content_type=build_content_type(desired_format),
**response_kwargs)
def is_key_valid(request, **kwargs):
user_key = request.GET.get('user_key')
try:
user_key = UserApiKey.objects.get(key=user_key)
key_valid = True
except UserApiKey.DoesNotExist:
key_valid = False
# self.log_throttled_access(request)
serializer = Serializer()
desired_format = determine_format(request, serializer)
serialized = serializer.serialize({'valid': key_valid}, desired_format)
return HttpResponse(content=serialized,
content_type=build_content_type(desired_format))
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 is_valid(self, bundle, request=None):
# prepare user id
user_id = None
if hasattr(request, 'user') and request.user.is_authenticated():
user_id = request.user.id
# prepare event id
event_id = None
event_uri = bundle.data.get('event')
if event_uri:
try:
view, args, kwargs = resolve(event_uri)
event_id = kwargs.get('pk')
except Resolver404:
raise NotFound("The URL provided '%s' was not a link to a valid resource." % event_uri)
# prepare form with data
form = self._meta.validation.form_class(data=dict(
user=user_id,
event=event_id,
action=bundle.data.get('action', '').upper()
))
# non conventional form processing
if form.is_valid():
instance = form.instance
try:
event_action = EventAction.objects.get(
user=instance.user, event=instance.event
)
except EventAction.DoesNotExist:
event_action = instance
event_action.save()
else:
if not event_action.action == instance.action:
event_action.action = instance.action
event_action.save()
bundle.obj = event_action
# error handling
else:
if request:
desired_format = self.determine_format(request)
else:
desired_format = self._meta.default_format
serialized = self.serialize(request, form.errors, desired_format)
response = HttpBadRequest(content=serialized, content_type=build_content_type(desired_format))
raise ImmediateHttpResponse(response=response)
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))
