add geo_polygon filter

Author: olivere

README.md

@@ -245,7 +245,7 @@ Here's the current API status.
 * `geo_bbox` (missing)
 * `geo_distance` (missing)
 * `geo_distance_range` (missing)
-* `geo_polygon` (missing)
+* `geo_polygon` (ok)
 * `geo_shape` (missing)
 * `has_child` (ok)
 * `has_parent` (ok)

geo_point.go

@@ -0,0 +1,43 @@
+package elastic
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// GeoPoint is a geographic position described via latitude and longitude.
+type GeoPoint struct {
+	Lat, Lon float64
+}
+
+// Source returns the object to be serialized in Elasticsearch DSL.
+func (pt *GeoPoint) Source() map[string]float64 {
+	return map[string]float64{
+		"lat": pt.Lat,
+		"lon": pt.Lon,
+	}
+}
+
+// GeoPointFromLatLon initializes a new GeoPoint by latitude and longitude.
+func GeoPointFromLatLon(lat, lon float64) *GeoPoint {
+	return &GeoPoint{Lat: lat, Lon: lon}
+}
+
+// GeoPointFromString initializes a new GeoPoint by a string that is
+// formatted as "{latitude},{longitude}", e.g. "40.10210,-70.12091".
+func GeoPointFromString(latLon string) (*GeoPoint, error) {
+	latlon := strings.SplitN(latLon, ",", 2)
+	if len(latlon) != 2 {
+		return nil, fmt.Errorf("elastic: %s is not a valid geo point string", latLon)
+	}
+	lat, err := strconv.ParseFloat(latlon[0], 64)
+	if err != nil {
+		return nil, err
+	}
+	lon, err := strconv.ParseFloat(latlon[1], 64)
+	if err != nil {
+		return nil, err
+	}
+	return &GeoPoint{Lat: lat, Lon: lon}, nil
+}

geo_point_test.go

@@ -0,0 +1,20 @@
+package elastic
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestGeoPointSource(t *testing.T) {
+	pt := GeoPoint{Lat: 40, Lon: -70}
+
+	data, err := json.Marshal(pt.Source())
+	if err != nil {
+		t.Fatalf("marshaling to JSON failed: %v", err)
+	}
+	got := string(data)
+	expected := `{"lat":40,"lon":-70}`
+	if got != expected {
+		t.Errorf("expected\n%s\n,got:\n%s", expected, got)
+	}
+}

search_filters_geo_polygon.go

@@ -0,0 +1,81 @@
+// Copyright 2012 Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+// A filter allowing to include hits that only fall within a polygon of points.
+// For details, see:
+// http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-geo-polygon-filter.html
+type GeoPolygonFilter struct {
+	Filter
+	name       string
+	points     []*GeoPoint
+	cache      *bool
+	cacheKey   string
+	filterName string
+}
+
+func NewGeoPolygonFilter(name string) GeoPolygonFilter {
+	f := GeoPolygonFilter{name: name, points: make([]*GeoPoint, 0)}
+	return f
+}
+
+func (f GeoPolygonFilter) Cache(cache bool) GeoPolygonFilter {
+	f.cache = &cache
+	return f
+}
+
+func (f GeoPolygonFilter) CacheKey(cacheKey string) GeoPolygonFilter {
+	f.cacheKey = cacheKey
+	return f
+}
+
+func (f GeoPolygonFilter) FilterName(filterName string) GeoPolygonFilter {
+	f.filterName = filterName
+	return f
+}
+
+func (f GeoPolygonFilter) AddPoint(point *GeoPoint) GeoPolygonFilter {
+	f.points = append(f.points, point)
+	return f
+}
+
+func (f GeoPolygonFilter) Source() interface{} {
+	// "geo_polygon" : {
+	//  	"person.location" : {
+	//         "points" : [
+	//             {"lat" : 40, "lon" : -70},
+	//             {"lat" : 30, "lon" : -80},
+	//             {"lat" : 20, "lon" : -90}
+	//         ]
+	//     }
+	// }
+	source := make(map[string]interface{})
+
+	params := make(map[string]interface{})
+	source["geo_polygon"] = params
+
+	polygon := make(map[string]interface{})
+	params[f.name] = polygon
+
+	points := make([]interface{}, 0)
+	for _, point := range f.points {
+		points = append(points, point.Source())
+	}
+	polygon["points"] = points
+
+	if f.filterName != "" {
+		params["_name"] = f.filterName
+	}
+
+	if f.cache != nil {
+		params["_cache"] = *f.cache
+	}
+
+	if f.cacheKey != "" {
+		params["_cache_key"] = f.cacheKey
+	}
+
+	return source
+}

search_filters_geo_polygon_test.go

@@ -0,0 +1,26 @@
+package elastic
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestGeoPolygonFilter(t *testing.T) {
+	f := NewGeoPolygonFilter("person.location")
+	f = f.AddPoint(&GeoPoint{Lat: 40, Lon: -70})
+	f = f.AddPoint(GeoPointFromLatLon(30, -80))
+	point, err := GeoPointFromString("20,-90")
+	if err != nil {
+		t.Fatalf("GeoPointFromString failed: %v", err)
+	}
+	f = f.AddPoint(point)
+	data, err := json.Marshal(f.Source())
+	if err != nil {
+		t.Fatalf("marshaling to JSON failed: %v", err)
+	}
+	got := string(data)
+	expected := `{"geo_polygon":{"person.location":{"points":[{"lat":40,"lon":-70},{"lat":30,"lon":-80},{"lat":20,"lon":-90}]}}}`
+	if got != expected {
+		t.Errorf("expected\n%s\n,got:\n%s", expected, got)
+	}
+}