rest/__init__.py

   1 from manifold.core.query            import Query
   2 from manifoldapi.manifoldapi        import execute_query
   3
   4 from django.http                    import HttpResponse
   5
   6
   7 import decimal
   8 import datetime
   9 import json
  10
  11 # handles serialization of datetime in json
  12 DateEncoder = lambda obj: obj.strftime("%B %d, %Y %H:%M:%S") if isinstance(obj, datetime.datetime) else None
  13
  14 # support converting decimal in json
  15 json.encoder.FLOAT_REPR = lambda o: format(o, '.2f')
  16
  17 # handles decimal numbers serialization in json
  18 class DecimalEncoder(json.JSONEncoder):
  19     def _iterencode(self, o, markers=None):
  20         if isinstance(o, decimal.Decimal):
  21             return (str(o) for o in [o])
  22         return super(DecimalEncoder, self)._iterencode(o, markers)
  23
  24 class ObjectRequest(object):
  25
  26     def __init__(self, request, object_type, object_name):
  27         self.type = object_type
  28         self.name = object_name
  29         self.fields = []
  30         self.params = []
  31         self.filters = {}
  32         self.options = None
  33
  34         self.request = request
  35
  36         if ((self.type == 'platform') or (self.type == 'testbed')) :
  37             self.type = 'local:platform'
  38             self.id = 'platform'
  39             self.fields = ['platform', 'platform_longname', 'platform_url', 'platform_description','gateway_type'];
  40             self.filters['disabled'] = '0'
  41             self.filters['gateway_type'] = 'sfa'
  42             self.filters['platform'] = '!myslice'
  43         #elif(self.type.startswith('local:')):
  44         elif ':' in self.type:
  45             table = self.type.split(':')
  46             prefix = table[0]
  47             table = table[1]
  48
  49             if prefix is 'local':
  50                 # XXX TODO: find a generic Query to get the fields like
  51                 # select column.name from local:object where table == local:user
  52                 table = self.type.split(':')
  53                 table = table[1]
  54                 if table == "user":
  55                     self.id = table + '_id'
  56                     self.fields = ['user_id', 'email', 'password', 'config','status'];
  57                 elif table == "account":
  58                     # XXX TODO: Multiple key for account = (platform_id, user_id)
  59                     self.id = "platform_id, user_id"
  60                     self.fields = ['platform_id', 'user_id', 'auth_type', 'config'];
  61                 elif table == "platform":
  62                     self.id = 'platform'
  63                     self.fields = ['platform', 'platform_longname', 'platform_url', 'platform_description','gateway_type'];
  64             else:
  65                 # If we use prefix, set the key without the prefix then add it again
  66                 self.type = table
  67                 self.setKey()
  68                 self.setLocalFields()
  69                 self.type = prefix + ':' + table
  70         else :
  71             self.setKey()
  72             self.setLocalFields()
  73
  74     def setKey(self):
  75         # What about key formed of multiple fields???
  76         query = Query.get('local:object').filter_by('table', '==', self.type).select('key')
  77         print query
  78         results = execute_query(self.request, query)
  79         print "key of object = %s" % results
  80         if results :
  81             for r in results[0]['key'] :
  82                 self.id = r
  83         else :
  84             raise Exception, 'Manifold db error'
  85
  86     def setLocalFields(self):
  87         query = Query.get('local:object').filter_by('table', '==', self.type).select('column.name')
  88         results = execute_query(self.request, query)
  89         if results :
  90             for r in results[0]['column'] :
  91                 self.fields.append(r['name'])
  92         else :
  93             raise Exception, 'Manifold db error'
  94
  95     def setFields(self, fields):
  96 #         selected_fields = []
  97 #         for p in fields :
  98 #             if p in self.fields :
  99 #                 selected_fields.append(p)
 100         self.fields = fields
 101
 102
 103     def applyFilters(self, query, force_filters = False):
 104         if (force_filters and not self.filters) :
 105             raise Exception, "Filters required"
 106         if self.filters :
 107             for k, f in self.filters.iteritems() :
 108                 if (f[:1] == "!") :
 109                     query.filter_by(k, '!=', f[1:])
 110                 elif (f[:2] == ">=") :
 111                     query.filter_by(k, '>=', f[2:])
 112                 elif (f[:1] == ">") :
 113                     query.filter_by(k, '>', f[1:])
 114                 elif (f[:2] == "<=") :
 115                     query.filter_by(k, '<=', f[2:])
 116                 elif (f[:1] == "<") :
 117                     query.filter_by(k, '<', f[1:])
 118                 elif (f[:8] == "CONTAINS") :
 119                     query.filter_by(k, 'CONTAINS', f[8:])
 120                 else :
 121                     query.filter_by(k, '==', f)
 122         return query
 123
 124     def get(self):
 125         query = Query.get(self.type)
 126         if (self.id is not None) and (self.id not in self.fields) :
 127             query.select(self.fields + [self.id])
 128         else :
 129             query.select(self.fields)
 130
 131         query = self.applyFilters(query)
 132         return execute_query(self.request, query)
 133
 134     def create(self):
 135         query = Query.create(self.type)
 136         # No filters for create
 137         if self.params :
 138             for p in self.params :
 139                 for k,v in p.iteritems() :
 140                     print "param: %s : %s" % (k,v)
 141                     query.set({k : v})
 142             print "query = ",query
 143         else:
 144             raise Exception, "Params are required for create"
 145         return execute_query(self.request, query)
 146
 147     def update(self):
 148         query = Query.update(self.type)
 149         query = self.applyFilters(query, True)
 150
 151         if self.params :
 152             for p in self.params :
 153                 for k,v in p.iteritems() :
 154                     print "param: %s : %s" % (k,v)
 155                     query.set({k : v})
 156             print "query = ",query
 157         else:
 158             raise Exception, "Params are required for update"
 159
 160         if self.id is not None:
 161            query.select(self.id)
 162
 163         return execute_query(self.request, query)
 164
 165     def delete(self):
 166         query = Query.delete(self.type)
 167         query = self.applyFilters(query, True)
 168         if self.filters :
 169             query.set(self.filters)
 170         else:
 171             raise Exception, "Filters are required for delete"
 172         return execute_query(self.request, query)
 173
 174     def json(self):
 175         return HttpResponse(json.dumps(self.get(), cls=DecimalEncoder, default=DateEncoder), content_type="application/json")
 176
 177     def datatable(self):
 178         response = self.get()
 179         response_data = {}
 180         response_data['fields'] = self.fields
 181         response_data['labels'] = self.fields
 182         response_data['data'] = []
 183         response_data['total'] = len(response)
 184         for r in response :
 185             d = []
 186             for p in self.fields :
 187                 d.append(r[p])
 188             response_data['data'].append(d)
 189
 190         return HttpResponse(json.dumps(response_data, cls=DecimalEncoder, default=DateEncoder), content_type="application/json")
 191
 192 def error(msg):
 193     return HttpResponse(json.dumps({'error' : msg}), content_type="application/json")
 194
 195 def success(msg):
 196     return HttpResponse(json.dumps({'success' : msg}), content_type="application/json")