Add Type Polygon to Schema and PolygonContains to query (#455)

* Add Type Polygon to Schema and PolygonContains to query

* Corrects Guide Link in README.md (#457)

Just a small fix of `https` to `http` for the JS guide link, which is only available over `http`.

* Addresses flaky test (#458)

* Update ParseGeoPointTest.js

* Limit request attempts to 1

* explore

* Marks flaky test as pending

* Add methods `addAll`, `addAllUnique` and `removeAll` (#459)

* Add methods `addAll`, `addAllUnique` and `removeAll`

* Add methods `addAll`, `addAllUnique` and `removeAll`

* Add test for `addAll`, `addAllUnique` and `removeAll`

* Revert test case

* containsPoint

uses bounded box first then ray casting

* update parse-server to 2.6.0

* Add Type Polygon to Schema and PolygonContains to query

* containsPoint

uses bounded box first then ray casting

* update parse-server to 2.6.0

Author: dplewis

integration/package.json

@@ -3,7 +3,7 @@
   "dependencies": {
     "express": "^4.13.4",
     "mocha": "^2.4.5",
-    "parse-server": "^2.4.2"
+    "parse-server": "^2.6.0"
   },
   "scripts": {
     "test": "mocha --reporter dot -t 5000"

integration/test/ParseGeoPointTest.js

@@ -291,7 +291,7 @@ describe('Geo Point', () => {
     const query = new Parse.Query(TestPoint);
     query.withinPolygon('location', []);
     query.find().then(done.fail, (err) => {
-      assert.equal(err.code, Parse.Error.INTERNAL_SERVER_ERROR);
+      assert.equal(err.code, Parse.Error.INVALID_JSON);
       done();
     })
     .fail(done.fail);

integration/test/ParsePolygonTest.js

@@ -0,0 +1,160 @@
+const assert = require('assert');
+const clear = require('./clear');
+const Parse = require('../../node');
+
+const TestObject = Parse.Object.extend('TestObject');
+
+describe('Polygon', () => {
+  before(() => {
+    Parse.initialize('integration');
+    Parse.CoreManager.set('SERVER_URL', 'http://localhost:1337/parse');
+    Parse.Storage._clear();
+  });
+
+  beforeEach((done) => {
+    clear().then(() => {
+      done();
+    });
+  });
+
+  it('can save polygon with points', (done) => {
+    const openPoints = [[0,0], [0,1], [1,1], [1,0]];
+    const closedPoints = [[0,0], [0,1], [1,1], [1,0], [0,0]];
+    const polygon = new Parse.Polygon(openPoints);
+    const obj = new TestObject({ polygon });
+    obj.save().then(() => {
+      const query = new Parse.Query(TestObject);
+      query.equalTo('polygon', polygon);
+      return query.find();
+    }).then((results) => {
+      assert.equal(results.length, 1);
+      assert.deepEqual(results[0].get('polygon').coordinates, closedPoints);
+      const closedPolygon = new Parse.Polygon(closedPoints);
+      const query = new Parse.Query(TestObject);
+      query.equalTo('polygon', closedPolygon);
+      return query.find();
+    }).then((results) => {
+      assert.equal(results.length, 1);
+      assert.deepEqual(results[0].get('polygon').coordinates, closedPoints);
+      done();
+    }, done.fail);
+  });
+
+  it('can save polygon with GeoPoints', (done) => {
+    const p1 = new Parse.GeoPoint(0, 0);
+    const p2 = new Parse.GeoPoint(0, 1);
+    const p3 = new Parse.GeoPoint(1, 1);
+    const p4 = new Parse.GeoPoint(1, 0);
+    const p5 = new Parse.GeoPoint(0, 0);
+    const closedPoints = [[0,0], [0,1], [1,1], [1,0], [0,0]];
+    const polygon = new Parse.Polygon([p1, p2, p3, p4, p5]);
+    const obj = new TestObject({ polygon });
+    obj.save().then(() => {
+      const query = new Parse.Query(TestObject);
+      query.equalTo('polygon', polygon);
+      return query.find();
+    }).then((results) => {
+      assert.equal(results.length, 1);
+      assert.deepEqual(results[0].get('polygon').coordinates, closedPoints);
+      const closedPolygon = new Parse.Polygon(closedPoints);
+      const query = new Parse.Query(TestObject);
+      query.equalTo('polygon', closedPolygon);
+      return query.find();
+    }).then((results) => {
+      assert.deepEqual(results[0].get('polygon').coordinates, closedPoints);
+      done();
+    }, done.fail);
+  });
+
+  it('fail save with 3 point minumum', (done) => {
+    try {
+      const polygon = new Parse.Polygon([[0, 0]]);
+    } catch (e) {
+      done();
+    }
+  });
+
+  it('fail save with non array', (done) => {
+    try {
+      const polygon = new Parse.Polygon(123);
+    } catch (e) {
+      done();
+    }
+  });
+
+  it('fail save with invalid array', (done) => {
+    try {
+      const polygon = new Parse.Polygon([['str1'], ['str2'], ['str3']]);
+    } catch (e) {
+      done();
+    }
+  });
+
+  it('containsPoint', (done) => {
+    const points = [[0,0], [0,1], [1,1], [1,0]];
+    const inside = new Parse.GeoPoint(0.5, 0.5);
+    const outside = new Parse.GeoPoint(10, 10);
+    const polygon = new Parse.Polygon(points);
+
+    assert.equal(polygon.containsPoint(inside), true);
+    assert.equal(polygon.containsPoint(outside), false);
+    done();
+  });
+
+  it('equality', (done) => {
+    const points = [[0,0], [0,1], [1,1], [1,0]];
+    const diff = [[0,0], [0,2], [2,2], [2,0]];
+
+    const polygonA = new Parse.Polygon(points);
+    const polygonB = new Parse.Polygon(points);
+    const polygonC = new Parse.Polygon(diff);
+
+    assert.equal(polygonA.equals(polygonA), true);
+    assert.equal(polygonA.equals(polygonB), true);
+    assert.equal(polygonB.equals(polygonA), true);
+
+    assert.equal(polygonA.equals(true), false);
+    assert.equal(polygonA.equals(polygonC), false);
+
+    done();
+  });
+
+  it('supports polygonContains', (done) => {
+    const p1 = [[0,0], [0,1], [1,1], [1,0]];
+    const p2 = [[0,0], [0,2], [2,2], [2,0]];
+    const p3 = [[10,10], [10,15], [15,15], [15,10], [10,10]];
+
+    const polygon1 = new Parse.Polygon(p1);
+    const polygon2 = new Parse.Polygon(p2);
+    const polygon3 = new Parse.Polygon(p3);
+
+    const obj1 = new TestObject({ polygon: polygon1 });
+    const obj2 = new TestObject({ polygon: polygon2 });
+    const obj3 = new TestObject({ polygon: polygon3 });
+
+    Parse.Object.saveAll([obj1, obj2, obj3]).then(() => {
+      const point = new Parse.GeoPoint(0.5, 0.5);
+      const query = new Parse.Query(TestObject);
+      query.polygonContains('polygon', point);
+      return query.find();
+    }).then((results) => {
+      assert.equal(results.length, 2);
+      done();
+    }, done.fail);
+  });
+
+  it('polygonContains invalid input', (done) => {
+    const points = [[0,0], [0,1], [1,1], [1,0]];
+    const polygon = new Parse.Polygon(points);
+    const obj = new TestObject({ polygon });
+    obj.save().then(() => {
+      const query = new Parse.Query(TestObject);
+      query.polygonContains('polygon', 1234);
+      return query.find();
+    }).then(() => {
+      fail();
+    }).catch(() => {
+      done();
+    });
+  });
+});

src/Parse.js

@@ -99,6 +99,7 @@ Parse.Error = require('./ParseError').default;
 Parse.FacebookUtils = require('./FacebookUtils').default;
 Parse.File = require('./ParseFile').default;
 Parse.GeoPoint = require('./ParseGeoPoint').default;
+Parse.Polygon = require('./ParsePolygon').default;
 Parse.Installation = require('./ParseInstallation').default;
 Parse.Object = require('./ParseObject').default;
 Parse.Op = {

src/ParsePolygon.js

@@ -0,0 +1,147 @@
+/**
+ * Copyright (c) 2015-present, Parse, LLC.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @flow
+ */
+
+import ParseGeoPoint from './ParseGeoPoint';
+
+/**
+ * Creates a new Polygon with any of the following forms:<br>
+ *   <pre>
+ *   new Polygon([[0,0],[0,1],[1,1],[1,0]])
+ *   new Polygon([GeoPoint, GeoPoint, GeoPoint])
+ *   </pre>
+ * @class Parse.GeoPoint
+ * @constructor
+ *
+ * <p>Represents a coordinates that may be associated
+ * with a key in a ParseObject or used as a reference point for geo queries.
+ * This allows proximity-based queries on the key.</p>
+ *
+ * <p>Example:<pre>
+ *   var polygon = new Parse.Polygon([[0,0],[0,1],[1,1],[1,0]]);
+ *   var object = new Parse.Object("PlaceObject");
+ *   object.set("area", polygon);
+ *   object.save();</pre></p>
+ */
+export default class ParsePolygon {
+  _coordinates: Array;
+
+  constructor(
+    arg1: Array,
+  ) {
+    this._coordinates = ParsePolygon._validate(arg1);
+  }
+
+  /**
+   * Coordinates value for this Polygon.
+   * Throws an exception if not valid type.
+   * @property coordinates
+   * @type Array
+   */
+  get coordinates(): Array {
+    return this._coordinates;
+  }
+
+  set coordinates(coords: Array) {
+    this._coordinates = ParsePolygon._validate(coords);
+  }
+
+  /**
+   * Returns a JSON representation of the GeoPoint, suitable for Parse.
+   * @method toJSON
+   * @return {Object}
+   */
+  toJSON(): { __type: string; coordinates: Array;} {
+    ParsePolygon._validate(this._coordinates);
+    return {
+      __type: 'Polygon',
+      coordinates: this._coordinates,
+    };
+  }
+
+  equals(other: mixed): boolean {
+    if (!(other instanceof ParsePolygon) || (this.coordinates.length !== other.coordinates.length)) {
+      return false;
+    }
+    let isEqual = true;
+
+    for (let i = 1; i < this._coordinates.length; i += 1) {
+      if (this._coordinates[i][0] != other.coordinates[i][0] ||
+          this._coordinates[i][1] != other.coordinates[i][1]) {
+        isEqual = false;
+        break;
+      }
+    }
+    return isEqual;
+  }
+
+  containsPoint(point: ParseGeoPoint): boolean {
+    let minX = this._coordinates[0][0];
+    let maxX = this._coordinates[0][0];
+    let minY = this._coordinates[0][1];
+    let maxY = this._coordinates[0][1];
+
+    for (let i = 1; i < this._coordinates.length; i += 1) {
+        const p = this._coordinates[i];
+        minX = Math.min(p[0], minX);
+        maxX = Math.max(p[0], maxX);
+        minY = Math.min(p[1], minY);
+        maxY = Math.max(p[1], maxY);
+    }
+
+    const outside = (point.latitude < minX || point.latitude > maxX || point.longitude < minY || point.longitude > maxY);
+    if (outside) {
+        return false;
+    }
+
+    let inside = false;
+    for (let i = 0, j = this._coordinates.length - 1 ; i < this._coordinates.length; j = i++) {
+      let startX = this._coordinates[i][0];
+      let startY = this._coordinates[i][1];
+      let endX = this._coordinates[j][0];
+      let endY = this._coordinates[j][1];
+
+      const intersect = (( startY > point.longitude ) != ( endY > point.longitude ) &&
+          point.latitude < ( endX - startX ) * ( point.longitude - startY ) / ( endY - startY ) + startX);
+
+      if (intersect) {
+          inside = !inside;
+      }
+    }
+    return inside;
+  }
+
+  /**
+   * Throws an exception if the given lat-long is out of bounds.
+   * @return {Array}
+   */
+  static _validate(coords: Array) {
+    if (!Array.isArray(coords)) {
+      throw new TypeError('Coordinates must be an Array');
+    }
+    if (coords.length < 3) {
+      throw new TypeError('Polygon must have at least 3 GeoPoints or Points');
+    }
+    const points = [];
+    for (let i = 0; i < coords.length; i += 1) {
+      const coord = coords[i];
+      let geoPoint;
+      if (coord instanceof ParseGeoPoint) {
+        geoPoint = coord;
+      } else if (Array.isArray(coord) && coord.length === 2) {
+        geoPoint = new ParseGeoPoint(coord[0], coord[1]);
+      } else {
+        throw new TypeError('Coordinates must be an Array of GeoPoints or Points');
+      }
+      points.push([geoPoint.latitude, geoPoint.longitude]);
+    }
+    return points;
+  }
+}

src/ParseQuery.js

@@ -13,6 +13,7 @@ import CoreManager from './CoreManager';
 import encode from './encode';
 import ParseError from './ParseError';
 import ParseGeoPoint from './ParseGeoPoint';
+import ParsePolygon from './ParsePolygon';
 import ParseObject from './ParseObject';
 import ParsePromise from './ParsePromise';
 
@@ -1013,6 +1014,19 @@ export default class ParseQuery {
     return this._addCondition(key, '$geoWithin', { '$polygon': points });
   }
 
+  /**
+   * Add a constraint to the query that requires a particular key's
+   * coordinates that contains a ParseGeoPoint
+   *
+   * @method polygonContains
+   * @param {String} key The key to be constrained.
+   * @param {Parse.GeoPoint} GeoPoint
+   * @return {Parse.Query} Returns the query, so you can chain this call.
+   */
+  polygonContains(key: string, point: ParseGeoPoint): ParseQuery {
+    return this._addCondition(key, '$geoIntersects', { '$point': point });
+  }
+
   /** Query Orderings **/
 
   /**

src/decode.js

@@ -12,6 +12,7 @@
 import ParseACL from './ParseACL';
 import ParseFile from './ParseFile';
 import ParseGeoPoint from './ParseGeoPoint';
+import ParsePolygon from './ParsePolygon';
 import ParseObject from './ParseObject';
 import { opFromJSON } from './ParseOp';
 import ParseRelation from './ParseRelation';
@@ -54,6 +55,9 @@ export default function decode(value: any): any {
       longitude: value.longitude
     });
   }
+  if (value.__type === 'Polygon') {
+    return new ParsePolygon(value.coordinates);
+  }
   var copy = {};
   for (var k in value) {
     copy[k] = decode(value[k]);

src/encode.js

@@ -12,6 +12,7 @@
 import ParseACL from './ParseACL';
 import ParseFile from './ParseFile';
 import ParseGeoPoint from './ParseGeoPoint';
+import ParsePolygon from './ParsePolygon';
 import ParseObject from './ParseObject';
 import { Op } from './ParseOp';
 import ParseRelation from './ParseRelation';
@@ -38,6 +39,7 @@ function encode(value: mixed, disallowObjects: boolean, forcePointers: boolean,
   if (value instanceof Op ||
       value instanceof ParseACL ||
       value instanceof ParseGeoPoint ||
+      value instanceof ParsePolygon ||
       value instanceof ParseRelation) {
     return value.toJSON();
   }