Syncano · opalczynski · Apr 29, 2016 · Apr 26, 2016 · Apr 26, 2016 · Apr 26, 2016
diff --git a/syncano/models/base.py b/syncano/models/base.py
@@ -8,4 +8,5 @@
 from .data_views import *  # NOQA
 from .incentives import *  # NOQA
 from .traces import *  # NOQA
-from .push_notification import *  # NOQA
+from .push_notification import *  # NOQA
+from .geo import *  # NOQA
diff --git a/syncano/models/fields.py b/syncano/models/fields.py
@@ -1,6 +1,5 @@
 import json
 import re
-from collections import namedtuple
 from datetime import date, datetime
 
 import six
@@ -9,6 +8,7 @@
 from syncano.exceptions import SyncanoFieldError, SyncanoValueError
 from syncano.utils import force_text
 
+from .geo import Distance, GeoPoint
 from .manager import SchemaManager
 from .registry import registry
 
@@ -687,13 +687,10 @@ def to_native(self, value):
         return value
 
 
-GeoPointStruct = namedtuple('GeoPointHelper', ['latitude', 'longitude'])
-
-
-class GeoPoint(Field):
+class GeoPointField(Field):
 
     def validate(self, value, model_instance):
-        super(GeoPoint, self).validate(value, model_instance)
+        super(GeoPointField, self).validate(value, model_instance)
 
         if not self.required and not value:
             return
@@ -704,28 +701,85 @@ def validate(self, value, model_instance):
             except (ValueError, TypeError):
                 raise SyncanoValueError('Expected an object')
 
-        if not isinstance(value, GeoPointStruct):
-            raise SyncanoValueError('Expected an GeoPointStruct')
+        if not isinstance(value, GeoPoint):
+            raise SyncanoValueError('Expected a GeoPoint')
 
     def to_native(self, value):
         if value is None:
             return
 
-        geo_struct = {'latitude': value[0], 'longitude': value[1]}
+        if isinstance(value, bool):
+            return value  # exists lookup
+
+        if isinstance(value, dict):
+            value = GeoPoint(latitude=value['latitude'], longitude=value['longitude'])
+
+        if isinstance(value, tuple):
+            geo_struct = value[0].to_native()
+        else:
+            geo_struct = value.to_native()
+
         geo_struct = json.dumps(geo_struct)
 
         return geo_struct
 
+    def to_query(self, value, lookup_type):
+        """
+        Returns field's value prepared for usage in HTTP request query.
+        """
+        super(GeoPointField, self).to_query(value, lookup_type)
+
+        if lookup_type not in ['near', 'exists']:
+            raise SyncanoValueError('Lookup {} not supported for geopoint field'.format(lookup_type))
+
+        if lookup_type in ['exists']:
+            if isinstance(value, bool):
+                return value
+            else:
+                raise SyncanoValueError('Bool expected in {} lookup.'.format(lookup_type))
+
+        if isinstance(value, dict):
+            value = (
+                GeoPoint(latitude=value.pop('latitude'), longitude=value.pop('longitude')),
+                Distance(**value)
+            )
+
+        if len(value) != 2 or not isinstance(value[0], GeoPoint) or not isinstance(value[1], Distance):
+            raise SyncanoValueError('This lookup should be a tuple with GeoPoint and Distance: '
+                                    '<field_name>__near=(GeoPoint(52.12, 22.12), Distance(kilometers=100))')
+
+        query_dict = value[0].to_native()
+        query_dict.update(value[1].to_native())
+
+        return query_dict
+
     def to_python(self, value):
         if value is None:
             return
 
+        value = self._process_string_types(value)
+
+        if isinstance(value, GeoPoint):
+            return value
+
+        latitude, longitude = self._process_value(value)
+
+        if not latitude or not longitude:
+            raise SyncanoValueError('Expected the `longitude` and `latitude` fields.')
+
+        return GeoPoint(latitude=latitude, longitude=longitude)
+
+    @classmethod
+    def _process_string_types(cls, value):
         if isinstance(value, six.string_types):
             try:
-                value = json.loads(value)
+                return json.loads(value)
             except (ValueError, TypeError):
                 raise SyncanoValueError('Invalid value: can not be parsed.')
+        return value
 
+    @classmethod
+    def _process_value(cls, value):
         longitude = None
         latitude = None
 
@@ -737,12 +791,9 @@ def to_python(self, value):
                 latitude = value[0]
                 longitude = value[1]
             except IndexError:
-                raise SyncanoValueError('Can not parse the geo struct.')
-
-        if not longitude or not latitude:
-            raise SyncanoValueError('Expected the `longitude` and `latitude` fields.')
+                raise SyncanoValueError('Can not parse the geo point.')
 
-        return GeoPointStruct(latitude, longitude)
+        return latitude, longitude
 
 
 MAPPING = {
@@ -768,5 +819,5 @@ def to_python(self, value):
     'schema': SchemaField,
     'array': ArrayField,
     'object': ObjectField,
-    'geopoint': GeoPoint,
+    'geopoint': GeoPointField,
 }
diff --git a/syncano/models/geo.py b/syncano/models/geo.py
@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+from syncano.exceptions import SyncanoValueError
+
+
+class GeoPoint(object):
+
+    def __init__(self, latitude, longitude):
+        self.latitude = latitude
+        self.longitude = longitude
+
+    def __repr__(self):
+        return "GeoPoint(latitude={}, longitude={})".format(self.latitude, self.longitude)
+
+    def to_native(self):
+        geo_struct_dump = {'latitude': self.latitude, 'longitude': self.longitude}
+        return geo_struct_dump
+
+
+class Distance(object):
+
+    KILOMETERS = '_in_kilometers'
+    MILES = '_in_miles'
+
+    def __init__(self, kilometers=None, miles=None):
+        if kilometers is not None and miles is not None:
+            raise SyncanoValueError('`kilometers` and `miles` can not be set at the same time.')
+
+        if kilometers is None and miles is None:
+            raise SyncanoValueError('`kilometers` or `miles` attribute should be specified.')
+
+        self.distance = kilometers or miles
+        self.unit = self.KILOMETERS if kilometers is not None else self.MILES
+
+    def to_native(self):
+        return {
+            'distance{}'.format(self.unit): self.distance
+        }
diff --git a/syncano/models/manager.py b/syncano/models/manager.py
@@ -882,7 +882,7 @@ class for :class:`~syncano.models.base.Object` model.
     LOOKUP_SEPARATOR = '__'
     ALLOWED_LOOKUPS = [
         'gt', 'gte', 'lt', 'lte',
-        'eq', 'neq', 'exists', 'in',
+        'eq', 'neq', 'exists', 'in', 'near'
     ]
 
     def __init__(self):

diff --git a/tests/integration_test_geo.py b/tests/integration_test_geo.py
@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+import six
+from syncano.exceptions import SyncanoValueError
+from syncano.models import Class, Distance, GeoPoint, Object
+from tests.integration_test import InstanceMixin, IntegrationTest
+
+
+class GeoPointApiTest(InstanceMixin, IntegrationTest):
+
+    @classmethod
+    def setUpClass(cls):
+        super(GeoPointApiTest, cls).setUpClass()
+
+        cls.city_model = Class.please.create(
+            instance_name=cls.instance.name,
+            name='city',
+            schema=[
+                {"name": "city", "type": "string"},
+                {"name": "location", "type": "geopoint", "filter_index": True},
+            ]
+        )
+
+        cls.warsaw = cls.city_model.objects.create(location=(52.2240698, 20.9942933), city='Warsaw')
+        cls.paris = cls.city_model.objects.create(location=(52.4731384, 13.5425588), city='Berlin')
+        cls.berlin = cls.city_model.objects.create(location=(48.8589101, 2.3125377), city='Paris')
+        cls.london = cls.city_model.objects.create(city='London')
+
+        cls.list_london = ['London']
+        cls.list_warsaw = ['Warsaw']
+        cls.list_warsaw_berlin = ['Warsaw', 'Berlin']
+        cls.list_warsaw_berlin_paris = ['Warsaw', 'Berlin', 'Paris']
+
+    def test_filtering_on_geo_point_near(self):
+
+        distances = {
+            100: self.list_warsaw,
+            600: self.list_warsaw_berlin,
+            1400: self.list_warsaw_berlin_paris
+        }
+
+        for distance, cities in six.iteritems(distances):
+            objects = Object.please.list(instance_name=self.instance.name, class_name="city").filter(
+                location__near={
+                    "latitude": 52.2297,
+                    "longitude": 21.0122,
+                    "kilometers": distance,
+                }
+            )
+
+            result_list = self._prepare_result_list(objects)
+
+            self.assertListEqual(result_list, cities)
+
+    def test_filtering_on_geo_point_near_miles(self):
+        objects = Object.please.list(instance_name=self.instance.name, class_name="city").filter(
+            location__near={
+                "latitude": 52.2297,
+                "longitude": 21.0122,
+                "miles": 10,
+            }
+        )
+        result_list = self._prepare_result_list(objects)
+        self.assertListEqual(result_list, self.list_warsaw)
+
+    def test_filtering_on_geo_point_near_with_another_syntax(self):
+        objects = self.city_model.objects.filter(
+            location__near=(GeoPoint(52.2297, 21.0122), Distance(kilometers=10))
+        )
+        result_list = self._prepare_result_list(objects)
+        self.assertListEqual(result_list, self.list_warsaw)
+
+        objects = self.city_model.objects.filter(
+            location__near=(GeoPoint(52.2297, 21.0122), Distance(miles=10))
+        )
+        result_list = self._prepare_result_list(objects)
+        self.assertListEqual(result_list, self.list_warsaw)
+
+    def test_filtering_on_geo_point_exists(self):
+        objects = self.city_model.objects.filter(
+            location__exists=True
+        )
+
+        result_list = [o.city for o in objects]
+
+        self.assertListEqual(result_list, self.list_warsaw_berlin_paris)
+
+        objects = self.city_model.objects.filter(
+            location__exists=False
+        )
+
+        result_list = self._prepare_result_list(objects)
+
+        self.assertListEqual(result_list, self.list_london)
+
+    def test_distance_fail(self):
+        with self.assertRaises(SyncanoValueError):
+            self.city_model.objects.filter(
+                location__near=(GeoPoint(52.2297, 21.0122), Distance(miles=10, kilometers=20))
+            )
+
+        with self.assertRaises(SyncanoValueError):
+            self.city_model.objects.filter(
+                location__near=(GeoPoint(52.2297, 21.0122), Distance())
+            )
+
+    def _prepare_result_list(self, objects):
+        return [o.city for o in objects]
diff --git a/tests/test_fields.py b/tests/test_fields.py
@@ -63,6 +63,7 @@ class AllFieldsModel(models.Model):
     schema_field = models.SchemaField()
     array_field = models.ArrayField()
     object_field = models.ObjectField()
+    geo_field = models.GeoPointField()
 
     class Meta:
         endpoints = {
@@ -571,3 +572,22 @@ def test_to_python(self):
 
         self.field.to_python({'raz': 1, 'dwa': 2})
         self.field.to_python('{"raz": 1, "dwa": 2}')
+
+
+class GeoPointTestCase(BaseTestCase):
+    field_name = 'geo_field'
+
+    def test_validate(self):
+
+        with self.assertRaises(SyncanoValueError):
+            self.field.validate(12, self.instance)
+
+        self.field.validate(models.GeoPoint(latitude=52.12, longitude=12.02), self.instance)
+
+    def test_to_python(self):
+        with self.assertRaises(SyncanoValueError):
+            self.field.to_python(12)
+
+        self.field.to_python((52.12, 12.02))
+        self.field.to_python({'latitude': 52.12, 'longitude': 12.02})
+        self.field.to_python(models.GeoPoint(52.12, 12.02))