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 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(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 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 _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 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))