Example #1
0
 def test_split_query(self):
     query = 'alpha "beta gamma"   delta  '
     from geonode.utils import _split_query
     keywords = _split_query(query)
     self.assertEqual(keywords[0], "alpha")
     self.assertEqual(keywords[1], "beta gamma")
     self.assertEqual(keywords[2], "delta")
Example #2
0
 def test_split_query(self):
     query = 'alpha "beta gamma"   delta  '
     from geonode.utils import _split_query
     keywords = _split_query(query)
     self.assertEqual(keywords[0], "alpha")
     self.assertEqual(keywords[1], "beta gamma")
     self.assertEqual(keywords[2], "delta")
Example #3
0
    def __init__(self,
                 query,
                 start=0,
                 limit=DEFAULT_SEARCH_SIZE,
                 sort_field='last_modified',
                 sort_asc=False,
                 filters=None,
                 user=None,
                 cache=True):
        self.query = query
        self.split_query = _split_query(query)
        self.start = start
        self.limit = limit
        self.sort = sort_field
        self.order = sort_asc
        self.params = filters or {}
        self.user = user
        self.cache = cache

        self.type = filters.get('type')
        self.owner = filters.get('owner')
        self.kw = filters.get('kw')
        if self.kw:
            self.kw = tuple(self.kw.split(','))

        val = filters['period']
        self.period = tuple(val.split(',')) if val else None

        start_date = filters['start_date']
        end_date = filters['end_date']
        if start_date or end_date:
            if self.period:
                raise BadQuery('period and start/end both provided')
            if len(start_date) == 10 and len(start_date) == 10:
                #if the date is in the format 'yyyy-mm-dd' make it iso format
                start_date += 'T00:00:00Z'
                end_date += 'T00:00:00Z'
            self.period = (start_date, end_date)

        val = filters['extent']
        if val:
            try:
                err = BadQuery(
                    'extent filter must contain x0,x1,y0,y1 comma separated')
                parts = val.split(',')
                if len(parts) != 4:
                    raise err
                self.extent = map(float, parts)
            except:
                raise err

        val = filters['added']
        self.added = parse_by_added(val) if val else None
Example #4
0
def _maps_search(query, start, limit, sort_field, sort_dir):

    keywords = _split_query(query)

    map_query = Map.objects
    for keyword in keywords:
        map_query = map_query.filter(
              Q(title__icontains=keyword)
            | Q(abstract__icontains=keyword))

    if sort_field:
        order_by = ("" if sort_dir == "ASC" else "-") + sort_field
        map_query = map_query.order_by(order_by)

    maps_list = []

    for m in map_query.all()[start:start+limit]:
        try:
            owner_name = Profile.objects.get(user=m.owner).name
        except Exception:
            owner_name = m.owner.first_name + " " + m.owner.last_name

        mapdict = {
            'id' : m.id,
            'title' : m.title,
            'abstract' : m.abstract,
            'detail' : reverse('map_detail', args=(m.id,)),
            'owner' : owner_name,
            'owner_detail' : reverse('profile_detail', args=(m.owner.username,)),
            'last_modified' : m.last_modified.isoformat()
            }
        maps_list.append(mapdict)

    result = {'rows': maps_list,
              'total': map_query.count()}

    result['query_info'] = {
        'start': start,
        'limit': limit,
        'q': query
    }
    if start > 0:
        prev = max(start - limit, 0)
        params = urlencode({'q': query, 'start': prev, 'limit': limit})
        result['prev'] = reverse('maps_search') + '?' + params

    next_page = start + limit + 1
    if next_page < map_query.count():
        params = urlencode({'q': query, 'start': next - 1, 'limit': limit})
        result['next'] = reverse('maps_search') + '?' + params

    return result
Example #5
0
    def __init__(self, query, start=0, limit=DEFAULT_SEARCH_SIZE,
                 sort_field='last_modified', sort_asc=False, filters=None,
                 user=None, cache=True):
        self.query = query
        self.split_query = _split_query(query)
        self.start = start
        self.limit = limit
        self.sort = sort_field
        self.order = sort_asc
        self.params = filters or {}
        self.user = user
        self.cache = cache

        self.type = tuple(filters.get('type').split(',')) if filters.get('type') else (None,)
        self.owner = filters.get('owner')
        self.kw = filters.get('kw')
        self.exclude = filters.get('exclude')
        self.categories = tuple(filters.get('category').split(',')) if filters.get('category') else None
        if self.kw:
            self.kw = tuple(self.kw.split(','))
        if self.exclude:
            self.exclude = tuple(self.exclude.split(','))

        val = filters['period']
        self.period = tuple(val.split(',')) if val else None

        start_date = filters['start_date']
        end_date = filters['end_date']
        if start_date or end_date:
            if self.period:
                raise BadQuery('period and start/end both provided')
            #if the date is in the format 'yyyy-mm-dd' make it iso format
            if start_date and len(start_date) == 10:   
                start_date += 'T00:00:00Z'
            if end_date and len(end_date) == 10:
                end_date += 'T00:00:00Z'
            self.period = (start_date, end_date)

        val = filters['extent']
        if val:
            try:
                err = BadQuery('extent filter must contain x0,x1,y0,y1 comma separated')
                parts = val.split(',')
                if len(parts) != 4:
                    raise err
                self.extent = map(float, parts)
            except:
                raise err

        val = filters['added']
        self.added = parse_by_added(val) if val else None
Example #6
0
def _maps_search(query, start, limit, sort_field, sort_dir):

    keywords = _split_query(query)

    map_query = Map.objects
    for keyword in keywords:
        map_query = map_query.filter(
            Q(title__icontains=keyword)
            | Q(abstract__icontains=keyword))

    if sort_field:
        order_by = ("" if sort_dir == "ASC" else "-") + sort_field
        map_query = map_query.order_by(order_by)

    maps_list = []

    for m in map_query.all()[start:start + limit]:
        try:
            owner_name = Profile.objects.get(user=m.owner).name
        except Exception:
            owner_name = m.owner.first_name + " " + m.owner.last_name

        mapdict = {
            'id': m.id,
            'title': m.title,
            'abstract': m.abstract,
            'detail': reverse('map_detail', args=(m.id, )),
            'owner': owner_name,
            'owner_detail': reverse('profile_detail',
                                    args=(m.owner.username, )),
            'last_modified': m.last_modified.isoformat()
        }
        maps_list.append(mapdict)

    result = {'rows': maps_list, 'total': map_query.count()}

    result['query_info'] = {'start': start, 'limit': limit, 'q': query}
    if start > 0:
        prev = max(start - limit, 0)
        params = urlencode({'q': query, 'start': prev, 'limit': limit})
        result['prev'] = reverse('maps_search') + '?' + params

    next_page = start + limit + 1
    if next_page < map_query.count():
        params = urlencode({'q': query, 'start': next - 1, 'limit': limit})
        result['next'] = reverse('maps_search') + '?' + params

    return result
Example #7
0
    def __init__(self, query, start=0, limit=DEFAULT_SEARCH_SIZE,
                 sort_field='last_modified', sort_asc=False, filters=None,
                 user=None, cache=True):
        self.query = query
        self.split_query = _split_query(query)
        self.start = start
        self.limit = limit
        self.sort = sort_field
        self.order = sort_asc
        self.params = filters or {}
        self.user = user
        self.cache = cache

        self.type = filters.get('type')
        self.owner = filters.get('owner')
        self.kw = filters.get('kw')
        if self.kw:
            self.kw = tuple(self.kw.split(','))

        val = filters['period']
        self.period = tuple(val.split(',')) if val else None

        start = filters['start']
        end = filters['end']
        if start or end:
            if self.period:
                raise BadQuery('period and start/end both provided')
            self.period = (start, end)

        val = filters['extent']
        if val:
            try:
                err = BadQuery('extent filter must contain x0,x1,y0,y1 comma separated')
                parts = val.split(',')
                if len(parts) != 4:
                    raise err
                self.extent = map(float, parts)
            except:
                raise err

        val = filters['added']
        self.added = parse_by_added(val) if val else None