manifold/manifoldquery.py

   1 import json
   2 import uuid
   3
   4 def uniqid ():
   5     return uuid.uuid4().hex
   6
   7 debug=False
   8 debug=True
   9
  10 class ManifoldQuery:
  11
  12     def __init__ (self, action=None, subject=None, timestamp='now',
  13                   filters=[], params=[], fields=[],
  14                   sort=None, limit=None, offset=None,
  15                   ):
  16         self.query_uuid=uniqid()
  17         # settable
  18         self.action=action
  19         self.subject=subject
  20         self.timestamp=timestamp
  21         self.filters=filters
  22         self.params=params
  23         self.fields=fields
  24         # xxx this is unused for now
  25         self.sort=sort
  26         self.limit=limit
  27         self.offset=offset
  28         # internal data - likewise, this is unused as of yet, although we have
  29         # (untested) code below in analyze_subqueries to compute these..
  30         self.analyzed_query=None
  31         self.subqueries = {}
  32
  33     def __repr__ (self):
  34         result="Q: id=%(query_uuid)s - %(action)s on %(subject)s "%self.__dict__
  35         result += " with %d filters, %d fields"%(len(self.filters),len(self.params))
  36         return result
  37
  38     def to_json (self):
  39         query_uuid=self.query_uuid
  40         a=self.action
  41         s=self.subject
  42         t=self.timestamp
  43         f=json.dumps (self.filters)
  44         print 'filters f=',f
  45         p=json.dumps (self.params)
  46         c=json.dumps (self.fields)
  47         # xxx unique can be removed, but for now we pad the js structure
  48         unique=0
  49
  50         aq = self.analyzed_query.to_json() if self.analyzed_query else 'null'
  51         # subqueries is a dictionary subject:query
  52         if not self.subqueries:
  53             sq="{}"
  54         else:
  55             sq=", ".join ( [ "'%s':%s" % (subject, subquery.to_json())
  56                       for (subject, subquery) in self.subqueries.iteritems()])
  57             sq="{%s}"%sq
  58
  59         result= """ new ManifoldQuery('%(a)s', '%(s)s', '%(t)s', %(f)s, %(p)s, %(c)s, %(unique)s, '%(query_uuid)s', %(aq)s, %(sq)s)"""%locals()
  60         if debug: print 'ManifoldQuery.to_json:',result
  61         return result
  62
  63     # this builds a ManifoldQuery object from a dict as received from javascript through its ajax request
  64     # e.g. here's what I captured from the server's output
  65     # incoming POST <QueryDict: {u'query[subject]': [u'slice'], u'query[fields][]': [u'slice_hrn'], u'query[timestamp]': [u'latest'], u'query[action]': [u'get']}>
  66     def fill_from_POST (self, d):
  67         for key in d.keys():
  68             for arg in ['action', 'subject', 'filters', 'fields', 'timestamp', 'params']:
  69                 if arg in key:
  70                     # dirty hack around fields; fields must be a list
  71                     if arg == 'fields':
  72                         setattr(self, arg, [d[key]])
  73                     else:
  74                         setattr(self, arg, d[key])
  75                     break
  76
  77     # not used yet ..
  78     def analyze_subqueries(self):
  79         analyzed_query = ManifoldQuery()
  80         analyzed_query.query_uuid = self.query_uuid
  81         analyzed_query.action = self.action
  82         analyzed_query.subject = self.subject
  83         analyzed_query.timestamp = self.timestamp
  84
  85         # analyse query filters
  86         # filter syntax : ['key', 'oparation', 'value']
  87         for filter in self.filters:
  88             key = filter[0]
  89             operation = filter[1]
  90             value = filter[2]
  91             if '.' in key:
  92                 parts=key.split('.')
  93                 subject = parts[0]
  94                 field = parts[1]
  95                 if not analyzed_query.subqueries[subject]:
  96                     subquery = ManifoldQuery()
  97                     subquery.action = self.action
  98                     subquery.subject = subject
  99                     subquery.timestamp = self.timestamp
 100                     analyzed_query.subqueries[subject] = subquery
 101
 102                 analyzed_query.subqueries[subject].filters.append([field, operation, value])
 103             else:
 104                 analyzed_query.filters.append(filter)
 105
 106         # analyse query params
 107         # params syntax : params = {'param1': value1, 'param2': value2, ...}
 108         for param in self.params.keys():
 109             if '.' in param:
 110                 parts=param.split('.')
 111                 subject = parts[0]
 112                 field = parts[1]
 113                 if not analyzed_query.subqueries[subject]:
 114                     subquery = ManifoldQuery()
 115                     subquery.action = self.action
 116                     subquery.subject = subject
 117                     subquery.timestamp = self.timestamp
 118                     analyzed_query.subqueries[subject] = subquery
 119
 120                 analyzed_query.subqueries[subject].params[field] = self.params[param]
 121             else:
 122                 analyzed_query.params[param] = self.params[param]
 123
 124         # analyse query fields
 125         # fields syntax: fields = [element1, element2, ....]
 126         for element in self.fields:
 127             if '.' in element:
 128                 parts=element.split('.')
 129                 subject = parts[0]
 130                 field = parts[1]
 131                 if not analyzed_query.subqueries[subject]:
 132                     subquery = ManifoldQuery()
 133                     subquery.action = self.action
 134                     subquery.subject = subject
 135                     subquery.timestamp = self.timestamp
 136                     analyzed_query.subqueries[subject] = subquery
 137
 138                 analyzed_query.subqueries[subject].fields.append(field)
 139             else:
 140                 analyzed_query.fields.append(element)
 141
 142
 143         # default subqueries
 144         if analyzed_query.subject == 'slice':
 145             if not analyzed_query.subqueries['resource']:
 146                 subquery = ManifoldQuery()
 147                 subquery.action = self.action
 148                 subquery.subject = subject
 149                 subquery.timestamp = self.timestamp
 150                 analyzed_query.subqueries['resource'] = subquery
 151
 152             if not analyzed_query.subqueries['lease']:
 153                 subquery = ManifoldQuery()
 154                 subquery.action = self.action
 155                 subquery.subject = subject
 156                 subquery.timestamp = self.timestamp
 157                 analyzed_query.subqueries['lease'] = subquery
 158
 159
 160         self.analyzed_query = analyzed_query