apps/piston/handler.py

   1 import warnings
   2
   3 from utils import rc
   4 from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned
   5 from django.conf import settings
   6
   7 typemapper = { }
   8 handler_tracker = [ ]
   9
  10 class HandlerMetaClass(type):
  11     """
  12     Metaclass that keeps a registry of class -> handler
  13     mappings.
  14     """
  15     def __new__(cls, name, bases, attrs):
  16         new_cls = type.__new__(cls, name, bases, attrs)
  17
  18         def already_registered(model, anon):
  19             for k, (m, a) in typemapper.iteritems():
  20                 if model == m and anon == a:
  21                     return k
  22
  23         if hasattr(new_cls, 'model'):
  24             if already_registered(new_cls.model, new_cls.is_anonymous):
  25                 if not getattr(settings, 'PISTON_IGNORE_DUPE_MODELS', False):
  26                     warnings.warn("Handler already registered for model %s, "
  27                         "you may experience inconsistent results." % new_cls.model.__name__)
  28
  29             typemapper[new_cls] = (new_cls.model, new_cls.is_anonymous)
  30         else:
  31             typemapper[new_cls] = (None, new_cls.is_anonymous)
  32
  33         if name not in ('BaseHandler', 'AnonymousBaseHandler'):
  34             handler_tracker.append(new_cls)
  35
  36         return new_cls
  37
  38 class BaseHandler(object):
  39     """
  40     Basehandler that gives you CRUD for free.
  41     You are supposed to subclass this for specific
  42     functionality.
  43
  44     All CRUD methods (`read`/`update`/`create`/`delete`)
  45     receive a request as the first argument from the
  46     resource. Use this for checking `request.user`, etc.
  47     """
  48     __metaclass__ = HandlerMetaClass
  49
  50     allowed_methods = ('GET', 'POST', 'PUT', 'DELETE')
  51     anonymous = is_anonymous = False
  52     exclude = ( 'id', )
  53     fields =  ( )
  54
  55     def flatten_dict(self, dct):
  56         return dict([ (str(k), dct.get(k)) for k in dct.keys() ])
  57
  58     def has_model(self):
  59         return hasattr(self, 'model') or hasattr(self, 'queryset')
  60
  61     def queryset(self, request):
  62         return self.model.objects.all()
  63
  64     def value_from_tuple(tu, name):
  65         for int_, n in tu:
  66             if n == name:
  67                 return int_
  68         return None
  69
  70     def exists(self, **kwargs):
  71         if not self.has_model():
  72             raise NotImplementedError
  73
  74         try:
  75             self.model.objects.get(**kwargs)
  76             return True
  77         except self.model.DoesNotExist:
  78             return False
  79
  80     def read(self, request, *args, **kwargs):
  81         if not self.has_model():
  82             return rc.NOT_IMPLEMENTED
  83
  84         pkfield = self.model._meta.pk.name
  85
  86         if pkfield in kwargs:
  87             try:
  88                 return self.queryset(request).get(pk=kwargs.get(pkfield))
  89             except ObjectDoesNotExist:
  90                 return rc.NOT_FOUND
  91             except MultipleObjectsReturned: # should never happen, since we're using a PK
  92                 return rc.BAD_REQUEST
  93         else:
  94             return self.queryset(request).filter(*args, **kwargs)
  95
  96     def create(self, request, *args, **kwargs):
  97         if not self.has_model():
  98             return rc.NOT_IMPLEMENTED
  99
 100         attrs = self.flatten_dict(request.POST)
 101
 102         try:
 103             inst = self.queryset(request).get(**attrs)
 104             return rc.DUPLICATE_ENTRY
 105         except self.model.DoesNotExist:
 106             inst = self.model(**attrs)
 107             inst.save()
 108             return inst
 109         except self.model.MultipleObjectsReturned:
 110             return rc.DUPLICATE_ENTRY
 111
 112     def update(self, request, *args, **kwargs):
 113         if not self.has_model():
 114             return rc.NOT_IMPLEMENTED
 115
 116         pkfield = self.model._meta.pk.name
 117
 118         if pkfield not in kwargs:
 119             # No pk was specified
 120             return rc.BAD_REQUEST
 121
 122         try:
 123             inst = self.queryset(request).get(pk=kwargs.get(pkfield))
 124         except ObjectDoesNotExist:
 125             return rc.NOT_FOUND
 126         except MultipleObjectsReturned: # should never happen, since we're using a PK
 127             return rc.BAD_REQUEST
 128
 129         attrs = self.flatten_dict(request.POST)
 130         for k,v in attrs.iteritems():
 131             setattr( inst, k, v )
 132
 133         inst.save()
 134         return rc.ALL_OK
 135
 136     def delete(self, request, *args, **kwargs):
 137         if not self.has_model():
 138             raise NotImplementedError
 139
 140         try:
 141             inst = self.queryset(request).get(*args, **kwargs)
 142
 143             inst.delete()
 144
 145             return rc.DELETED
 146         except self.model.MultipleObjectsReturned:
 147             return rc.DUPLICATE_ENTRY
 148         except self.model.DoesNotExist:
 149             return rc.NOT_HERE
 150
 151 class AnonymousBaseHandler(BaseHandler):
 152     """
 153     Anonymous handler.
 154     """
 155     is_anonymous = True
 156     allowed_methods = ('GET',)