taxonomy service

gistfile1.py

# ------------------------------------------------------------------------------
# TaxonomyService

class TaxonomyProvider(object):
    def __init__(self):
        pass
        
    def _key(self, k):
        raise NotImplementedError() 
        
    def _search(self, query):
        raise NotImplementedError() 
        
    def search(self, query):
        raise NotImplementedError() 
        
    def getdata(self, query):
        raise NotImplementedError() 

class TaxonomySearch(TaxonomyProvider):
    def __init__(self):
        super(TaxonomySearch, self).__init__()   
    
    def _key(self, k):
        key = db.Key.from_path('Species', k.lower())
        ent = Species.get(key)
        return [ent]
        
    def _search(self,query):
        
        res = []
        
        lim = 
        ofs = query.get('ofset', 0)
        
        q = SpeciesIndex
              .all(keys_only=True)
              
        for a, b in query.filters.items():
            q.filter("%s =" % str(a), b)
        
        if query.get('hasRangeMap', False) is True:
            q.filter('hasRangeMap =', True)
            
        if query.get('orderOn', None) is not None:
            q.order(orderOn['orderOn'])
        
        return q.fetch(lim, ofs)
        
    def search(self, query):
        if query.get('key', False):
            result = self._key(query.get('key', False))
        else:
            params = {}
            params['limit'] = query.get('limit', 25)
            params['offset'] = query.get('offset', 25)
            
            params['filters'] = {}
            
            filterDict = ['names',
                          'authorityName',
                          'authorityIdentifier',
                          'kingdom',
                          'phylum',
                          'class',
                          'order',
                          'superFamily',
                          'family',
                          'genus',
                          'species',
                          'infraSpecies',
                          'hasRangeMap']
            
            fct = 0 #keeps the number of passed filter to the allowable 2
            for filter in filterDict:
                f = filter
                if f in ['class','order']:
                    f = f+"_"
                if query.get(f, None) is not None and fct < 2:
                    if f == 'hasRangeMap' and query.get(filter, 'true') == 'true':
                        params['filters'][f] = query.get(filter, '')
                    else:
                        params['filters'][f] = str(query.get(filter, ''))
                    fct+=1
            result = self._search()
        return result
        
    def getdata(self, query):
        s = self.search(query)
        out = []
        for ent in s:
            k = ent.key_name
            ele = k.split("/")
            e = {
                 "rank": str(ele[-2]),
                 "name": str(ele[-1]).replace("_", " "),
                 "classification": simplejson.loads(ent.classification),
                 "authority": simplejson.loads(ent.authority),
                 "names": simplejson.loads(ent.names) #.replace('\\','')
                }
            out.append(e)
        return out