def post_detail(self, request, **kwargs):
pk = kwargs['pk'].strip("/")
metric = Metric.objects.get(pk=pk)
obs_class = metric.unit.observation_type.model_class()
if obs_class is RatioObservation:
return HttpNotImplemented()
else:
from_dt = iso8601.parse_date(request.POST['from_datetime']).replace(tzinfo=None)
to_dt = iso8601.parse_date(request.POST['to_datetime']).replace(tzinfo=None)
metric_obs = metric.related_observations
try:
ob = metric_obs.get(
metric = metric,
from_datetime = from_dt,
to_datetime = to_dt,
)
except obs_class.DoesNotExist:
ob = obs_class.objects.create(
metric = metric,
from_datetime = from_dt,
to_datetime = to_dt,
)
rawvalue = request.POST.get('value', None)
ob.value = self.deserialize(request, rawvalue)
ob.save()
url = "/observation/%s/" % ob.pk
return HttpCreated(location=url)
def test_various_statuses(self):
created = HttpCreated(location='http://example.com/thingy/1/')
self.assertEqual(created.status_code, 201)
self.assertEqual(created['Location'], 'http://example.com/thingy/1/')
# Regression.
created_2 = HttpCreated()
self.assertEqual(created_2.status_code, 201)
self.assertEqual(created_2['Location'], '')
accepted = HttpAccepted()
self.assertEqual(accepted.status_code, 202)
no_content = HttpNoContent()
self.assertEqual(no_content.status_code, 204)
see_other = HttpSeeOther()
self.assertEqual(see_other.status_code, 303)
not_modified = HttpNotModified()
self.assertEqual(not_modified.status_code, 304)
bad_request = HttpBadRequest()
self.assertEqual(bad_request.status_code, 400)
unauthorized = HttpUnauthorized()
self.assertEqual(unauthorized.status_code, 401)
not_found = HttpNotFound()
self.assertEqual(not_found.status_code, 404)
not_allowed = HttpMethodNotAllowed()
self.assertEqual(not_allowed.status_code, 405)
conflict = HttpConflict()
self.assertEqual(conflict.status_code, 409)
gone = HttpGone()
self.assertEqual(gone.status_code, 410)
toomanyrequests = HttpTooManyRequests()
self.assertEqual(toomanyrequests.status_code, 429)
not_implemented = HttpNotImplemented()
self.assertEqual(not_implemented.status_code, 501)
def post_detail(self, request, **kwargs):
"""
Creates a new subcollection of the resource under a resource.
This is not implemented by default because most people's data models
aren't self-referential.
If a new resource is created, return ``HttpCreated`` (201 Created).
"""
return HttpNotImplemented()
def serialize(self, bundle, format='application/json', options={}):
try:
return super(MySerializer, self).serialize(bundle, format, options)
except (ImproperlyConfigured, UnsupportedFormat):
raise ImmediateHttpResponse(
HttpNotImplemented(settings.HTTP_NOT_IMPLEMENTED_ERROR))
except ImmediateHttpResponse:
raise
except Exception:
raise ImmediateHttpResponse(
HttpApplicationError(settings.HTTP_APPLICATION_ERROR))
def apply_filters(self, request, applicable_filters):
"""An ORM-specific implementation of ``apply_filters``.
The default simply applies the ``applicable_filters`` as ``**kwargs``,
but should make it possible to do more advanced things.
"""
# List units only when a filter criterion was provided.
if not applicable_filters:
raise ImmediateHttpResponse(response=HttpNotImplemented())
return super(UnitResource, self).apply_filters(request,
applicable_filters)
def dispatch(self, request_type, request, **kwargs):
"""
From original Tastypie structure:
- lookup the API method
- authenticate
Other modifications:
- use of the "downloadID" cookie
"""
request_method = request.method.lower()
method = getattr(self, "%s_%s"
% (request_method, request_type), None)
if method is None:
raise ImmediateHttpResponse(response=HttpNotImplemented())
# self.is_authenticated(request)
convert_post_to_put(request)
logger.info('calling method: %s.%s_%s',
self._meta.resource_name, request_method, request_type)
response = method(request, **kwargs)
# # If what comes back isn't a ``HttpResponse``, assume that the
# # request was accepted and that some action occurred. This also
# # prevents Django from freaking out.
if not isinstance(response, HttpResponseBase):
return HttpNoContent()
# Custom ICCB parameter: set cookie to tell the browser javascript
# UI that the download request is finished
downloadID = request.GET.get('downloadID', None)
if downloadID:
logger.info('set cookie "downloadID" %r', downloadID )
response.set_cookie('downloadID', downloadID)
else:
logger.debug('no downloadID: %s' % request.GET )
return response
def obj_delete(self, request=None, **kwargs):
#obj = Result.objects.get(pk=kwargs['pk'])
#obj.delete()
return HttpNotImplemented()
def obj_delete_list(self, request=None, **kwargs):
return HttpNotImplemented()
def get_multiple(self, request, **kwargs):
return HttpNotImplemented()
def patch_list(self, request, **kwargs):
return HttpNotImplemented()
def patch_detail(self, request, **kwargs):
return HttpNotImplemented()
def delete_detail(self, request, **kwargs):
return HttpNotImplemented()
