/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.usergrid.persistence;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.usergrid.AbstractCoreIT;
import org.apache.usergrid.utils.MapUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
public class GeoIT extends AbstractCoreIT {
private static final Logger logger = LoggerFactory.getLogger(GeoIT.class);
int NEARBY_RADIUS = 10000;
int CIRCUMFERENCE_OF_THE_EARTH = 40000000;
/*
A list of concrete entities with locations to be used for geoQuery tests
NOTE: Adding or removing items from this list could affect test outcome!!!
*/
private static List<Map<String, Object>> LOCATION_PROPERTIES =
new ArrayList<Map<String, Object>>();
static {
LOCATION_PROPERTIES.add(new LinkedHashMap<String, Object>() {{
put("name", "norwest");
put("location", new LinkedHashMap<String, Object>() {{
put("latitude", -33.746369);
put("longitude", 150.952183);
}});
}});
LOCATION_PROPERTIES.add(new LinkedHashMap<String, Object>() {{
put("type", "store");
put("name", "ashfield");
put("location", new LinkedHashMap<String, Object>() {{
put("latitude", -33.889058);
put("longitude", 151.124024);
}});
}});
}
public GeoIT() throws Exception {
super();
}
@Test
public void testRoundingGeolocationIssue() throws Exception {
EntityManager em = app.getEntityManager();
assertNotNull(em);
//1. Create an entity with location
Entity office = createEntitywithLocation( em,"office",37.334115,-121.894340);
assertNotNull(office);
Entity pizza = createEntitywithLocation( em,"pizza",37.335616,-121.894168);
assertNotNull(pizza);
Entity market = createEntitywithLocation( em,"market",37.336499,-121.894356);
assertNotNull(market);
Entity park = createEntitywithLocation( em,"park",37.339079,-121.891422);
assertNotNull(park);
Entity news = createEntitywithLocation( em,"news",37.337812,-121.890784);
assertNotNull(news);
Entity hotel = createEntitywithLocation( em,"hotel",37.334370,-121.895081);
assertNotNull(hotel);
app.waitForQueueDrainAndRefreshIndex();
//2. Query with a globally large distance to verify location
Query query = Query.fromQL("select * where location within 609.7 of 37.334110260009766, -121.89434051513672");
Results listResults = em.searchCollection(em.getApplicationRef(), "collars", query);
assertEquals( 5, listResults.size());
query = Query.fromQL("select * where location within 609.8 of 37.334110260009766, -121.89434051513672");
listResults = em.searchCollection(em.getApplicationRef(), "collars", query);
assertEquals( 6, listResults.size());
}
private Entity createEntitywithLocation( final EntityManager em,String name ,Double lat,Double lon) throws Exception {
Map<String, Object> properties = new LinkedHashMap<String, Object>() {{
put("name", name);
put("location", new LinkedHashMap<String, Object>() {{
put("latitude", lat);
put("longitude", lon);
}});
}};
return em.create("collars", properties);
}
@Test
public void testRemovedLocationQuery() throws Exception {
//Get the EntityManager instance
EntityManager em = app.getEntityManager();
assertNotNull(em);
//1. Create an entity with location
Map<String, Object> properties = new LinkedHashMap<String, Object>() {{
put("username", "edanuff");
put("email", "ed@anuff.com");
put("location", new LinkedHashMap<String, Object>() {{
put("latitude", 37.776753);
put("longitude", -122.407846);
}});
}};
Entity user = em.create("user", properties);
assertNotNull(user);
app.waitForQueueDrainAndRefreshIndex();
//2. Query with a globally large distance to verify location
Query query = Query.fromQL("select * where location within " + Integer.MAX_VALUE + " of 0, 0");
Results listResults = em.searchCollection(em.getApplicationRef(), "users", query);
assertEquals("1 result returned", 1, listResults.size());
//3. Remove the entity's location
properties.remove("location");
user.getDynamicProperties().remove("location");
em.updateProperties(user, properties);
em.update(user);
app.waitForQueueDrainAndRefreshIndex();
//4. Repeat the query, expecting no results
listResults = em.searchCollection(em.getApplicationRef(), "users", query);
assertEquals(0, listResults.size());
em.delete(user);
}
/**
* Validate the ability to query a moving entity
* 1. Create an entity with location
* 2. Query from a point near the entity's location
* 3. Move the entity farther away from the center point
* 4. Run the same query again to verify the entity is no longer in the area
*/
@Test
public void testMovingTarget() throws Exception {
logger.info("GeoIT.testMovingTarget");
//Get the EntityManager instance
EntityManager em = app.getEntityManager();
assertNotNull(em);
//1. Create an entity with location
Map<String, Object> properties = new LinkedHashMap<String, Object>() {{
put("username", "edanuff");
put("email", "ed@anuff.com");
put("location", new LinkedHashMap<String, Object>() {{
put("latitude", 37.776753);
put("longitude", -122.407846);
}});
}};
Entity user = em.create("user", properties);
assertNotNull(user);
app.waitForQueueDrainAndRefreshIndex();
final double lat = 37.776753;
final double lon = -122.407846;
//2. Query from a point near the entity's location
Query query = Query.fromQL("select * where location within 100 of "
+ lat + "," + lon);
Results listResults = em.searchCollection(em.getApplicationRef(), "users", query);
assertEquals(1, listResults.size());
//3. Move the entity farther away from the center point
updatePos(em, user, 37.428526, -122.140916);
//4. Run the same query again to verify the entity is no longer in the area
listResults = em.searchCollection(em.getApplicationRef(), "users", query);
assertEquals(0, listResults.size());
em.delete(user);
}
/**
* Validate the ability to query a moving entity
* 1. Create an entity with location
* 2. Query from a point near the entity's location
* 3. Move the entity farther away from the center point
* 4. Run the same query again to verify the entity is no longer in the area
*/
@Test
public void validateDistanceQueryExists() throws Exception {
logger.info("GeoIT.validateDistanceQueryExists");
//Get the EntityManager instance
EntityManager em = app.getEntityManager();
assertNotNull(em);
//1. Create an entity with location
Map<String, Object> properties = new LinkedHashMap<String, Object>() {{
put("username", "edanuff");
put("email", "ed@anuff.com");
put("location", new LinkedHashMap<String, Object>() {{
put("latitude", 37.776753);
put("longitude", -122.407846);
}});
}};
Entity user = em.create("user", properties);
assertNotNull(user);
app.waitForQueueDrainAndRefreshIndex();
final double lat = 37.776753;
final double lon = -122.407846;
//2. Query from a point near the entity's location
Query query = Query.fromQL("select * where location within 100 of "
+ lat + "," + lon);
Results listResults = em.searchCollection(em.getApplicationRef(), "users", query);
assertEquals(1, listResults.size());
Entity entity = listResults.getEntity();
assertTrue(entity.getMetadata("distance")!=null);
assertTrue(Double.parseDouble( entity.getMetadata("distance").toString())>0);
em.delete(user);
}
/**
* Validate the ability to query connections within proximity of the users
* 1. Create an entity with location
* 2. Create a user with location
* 3. Create a connection between the user and the entity
* 4. Test that the user is within 2000m of the entity
* 5. Test that the user is NOT within 1000m of the entity
*/
@Test
public void testGeoDistanceOfConnection() throws Exception {
//Get the EntityManager instance
EntityManager em = app.getEntityManager();
assertNotNull(em);
//1. Create an entity with location
Map<String, Object> restaurantProps = new LinkedHashMap<String, Object>();
restaurantProps.put("name", "Brickhouse");
restaurantProps.put("address", "426 Brannan Street");
restaurantProps.put("location", getLocation(37.779632, -122.395131));
Entity restaurant = em.create("restaurant", restaurantProps);
assertNotNull(restaurant);
//2. Create a user with location
Map<String, Object> userProperties = new LinkedHashMap<String, Object>() {{
put("username", "edanuff");
put("email", "ed@anuff.com");
put("location", new LinkedHashMap<String, Object>() {{
put("latitude", 37.776753);
put("longitude", -122.407846);
}});
}};
Entity user = em.create("user", userProperties);
assertNotNull(user);
app.waitForQueueDrainAndRefreshIndex();
//3. Create a connection between the user and the entity
em.createConnection(user, "likes", restaurant);
app.waitForQueueDrainAndRefreshIndex();
//4. Test that the user is within 2000m of the entity
Results emSearchResults = em.searchTargetEntities(user,
Query.fromQL("location within 5000 of "
+ ((LinkedHashMap<String, Object>) userProperties.get("location")).get("latitude")
+ ", " + ((LinkedHashMap<String, Object>)
userProperties.get("location")).get("longitude")).setConnectionType("likes"));
assertEquals(1, emSearchResults.size());
//5. Test that the user is NOT within 1000m of the entity
emSearchResults = em.searchTargetEntities(user,
Query.fromQL("location within 1000 of "
+ ((LinkedHashMap<String, Object>) userProperties.get("location")).get("latitude")
+ ", " + ((LinkedHashMap<String, Object>)
userProperties.get("location")).get("longitude")).setConnectionType("likes"));
assertEquals(0, emSearchResults.size());
//cleanup
em.delete(user);
em.delete(restaurant);
}
/**
* Validate loaded entities for geo queries
* 1. load test entities
* 2. validate the size of the result
* 3. verify each entity has geo data
*/
@Test
public void testGeolocationEntities() throws Exception {
//1. load test entities
EntityManager em = app.getEntityManager();
assertNotNull(em);
//2. load test entities
for (Map<String, Object> location : LOCATION_PROPERTIES) {
Entity entity = em.create("store", location);
assertNotNull(entity);
logger.debug("Entity {} created", entity.getProperty("name"));
}
app.waitForQueueDrainAndRefreshIndex();
//2. validate the size of the result
Query query = new Query();
Results listResults = em.searchCollection(em.getApplicationRef(), "stores", query);
assertEquals("total number of 'stores'", LOCATION_PROPERTIES.size(), listResults.size());
//3. verify each entity has geo data
for (Entity entity : listResults.entities) {
Map location = (Map)entity.getProperty("location");
assertNotNull(location);
assertNotNull(location.get("longitude"));
assertNotNull(location.get("latitude"));
}
}
@Test
public void testNonGeolocationEntities() throws Exception {
//1. load test entities
EntityManager em = app.getEntityManager();
assertNotNull(em);
List<Map<String, Object>> locations =
new ArrayList<Map<String, Object>>();
locations.add(new LinkedHashMap<String, Object>() {{
put("name", "norwest");
put("location", "texas");
}});
locations.add(new LinkedHashMap<String, Object>() {{
put("type", "store");
put("name", "ashfield");
put("location", "new jersey");
}});
//2. load test entities
for (Map<String, Object> location : locations) {
Entity entity = em.create("store", location);
assertNotNull(entity);
logger.debug("Entity {} created", entity.getProperty("name"));
}
app.waitForQueueDrainAndRefreshIndex();
//2. validate the size of the result
Query query = new Query();
Results listResults = em.searchCollection(em.getApplicationRef(), "stores", query);
assertEquals("total number of 'stores'", locations.size(), listResults.size());
//3. verify each entity has geo data
for (Entity entity : listResults.entities) {
Object location = entity.getProperty("location");
assertNotNull(location);
assertTrue(location instanceof String);
}
query = Query.fromQL("select * where location='texas'");
listResults = em.searchCollection(em.getApplicationRef(), "stores", query);
assertEquals("total number of 'stores'", 1, listResults.size());
//3. verify each entity has geo data
for (Entity entity : listResults.entities) {
Object location = entity.getProperty("location");
assertNotNull(location);
assertTrue(location instanceof String);
}
}
@Test
/**
* Load entities with location data and query them from a far away location
* 1. create entities with geo
* 2. Query the collection from a point more than 10000m from the locations
* and ensure that no entities are returned when restricted to a 10000m radius
* 3. Query the collection from a point more than 10000m from the locations
* and ensure that all entities are returned when the distance is set to the
* circumference of the earth
*/
public void testGeoFromFarAwayLocation() throws Exception {
//1. create entities with geo
EntityManager em = loadGeolocationTestEntities();
//2. Query the collection from a point more than 10000m from the locations
// and ensure that no entities are returned when restricted to a 10000m radius
final double lat = 37.776753;
final double lon = -122.407846;
Query query = Query.fromQL("select * where location within " + NEARBY_RADIUS + " of "
+ lat + "," + lon);
Results listResults = em.searchCollection(em.getApplicationRef(), "stores", query);
assertEquals("Results within " + NEARBY_RADIUS + "m from center", 0, listResults.size());
//3. Query the collection from a point more than 10000m from the locations
// and ensure that all entities are returned when the distance is set to the
// circumference of the earth
Query query2 = Query.fromQL("select * where location within " + CIRCUMFERENCE_OF_THE_EARTH + " of "
+ lat + "," + lon);
listResults = em.searchCollection(em.getApplicationRef(), "stores", query2);
assertEquals("Results within " + CIRCUMFERENCE_OF_THE_EARTH
+ "m from center", LOCATION_PROPERTIES.size(), listResults.size());
}
@Test
/**
* Load entities with location data and query them from a nearby location
* 1. create entities with geo
* 2. Query the collection from a point less than 10000m from the locations
* and ensure that one entity is returned when restricted to a 10000m radius
* 3. Query the collection from a point less than 10000m from the locations
* and ensure that all entities are returned when the distance is set to the
* circumference of the earth
*/
public void testGeoFromNearbyLocation() throws Exception {
logger.info( "GeoIT.testGeoFromNearbyLocation" );
//1. create entities with geo
EntityManager em = loadGeolocationTestEntities();
final double lat = -33.746369;
final double lon = 150.952185;
//2. Query the collection from a point less than 10000m from the locations
// and ensure that one entity is returned when restricted to a 10000m radius
Query query = Query.fromQL("select * where location within " + NEARBY_RADIUS + " of "
+ lat + "," + lon);
Results listResults = em.searchCollection(em.getApplicationRef(), "stores", query);
assertEquals( "Results within " + NEARBY_RADIUS + "m from center", 1, listResults.size() );
//3. Query the collection from a point less than 10000m from the locations
// and ensure that all entities are returned when the distance is set to the
// circumference of the earth
query = Query.fromQL(
"select * where location within " + CIRCUMFERENCE_OF_THE_EARTH + " of " + lat + "," + lon );
listResults = em.searchCollection(em.getApplicationRef(), "stores", query);
assertEquals( "Results within " + CIRCUMFERENCE_OF_THE_EARTH + "m from center", LOCATION_PROPERTIES.size(),
listResults.size() );
}
/**
* Load entities with location data and query them from multiple locations
* to ensure proper bounds
* 1. Create entities with geo
* 2. Create a list of points from different geographic areas
* 3. Query the collection from each point
* and ensure that no entities are returned when restricted to a 10000m radius
* 4. Query the collection from each point
* and ensure that all entities are returned when the distance is set to the
* circumference of the earth
*/
@Test
public void testGeoFromMultipleLocations() throws Exception {
logger.info("GeoIT.testGeoFromMultipleLocations");
//1 Create entities with geo
EntityManager em = loadGeolocationTestEntities();
//2 Create a list of points from different geographic areas
List<double[]> points = new ArrayList<>();
points.add(new double[]{-90.000000, 90.000000});//Antarctica
points.add(new double[]{90, 90});;//Santa's house
points.add( new double[]{ 33.746369, -89});;//Woodland, MS
points.add( new double[] { 34.35, 58.22 } );; //Buenos Aires
points.add( new double[] { 39.55, 116.25 } );;//Beijing, China
points.add( new double[]{ 44.52, 20.32});; //Belgrade, Serbia
points.add( new double[] { -1.000000, 102.000000 } );;//Somewhere in Indonesia
for (double[] center : points) {
//3 Query the collection from each point
// and ensure that no entities are returned when restricted to a 10000m radius
final double lat = center[0];
final double lon = center[1];
Query query = Query.fromQL("select * where location within 10000 of "
+ lat + "," + lon);
Results listResults = em.searchCollection(em.getApplicationRef(), "stores", query);
assertEquals("Results less than 10000m away from center", 0, listResults.size());
//4 Query the collection from each point
// and ensure that all entities are returned when the distance is set to the
// circumference of the earth
Query query2 = Query.fromQL("select * where location within 40000000 of "
+ lat + "," + lon);
listResults = em.searchCollection(em.getApplicationRef(), "stores", query2);
assertEquals("Results from center point to ridiculously far",
LOCATION_PROPERTIES.size(), listResults.size());
}
}
@Test
public void testPointPaging() throws Exception {
EntityManager em = app.getEntityManager();
assertNotNull( em );
// save objects in a diagonal line from -90 -180 to 90 180
int numEntities = 50;
float minLattitude = -90;
float maxLattitude = 90;
float minLongitude = -180;
float maxLongitude = 180;
float lattitudeDelta = (maxLattitude - minLattitude) / numEntities;
float longitudeDelta = (maxLongitude - minLongitude) / numEntities;
for (int i = 0; i < numEntities; i++) {
float lattitude = minLattitude + lattitudeDelta * i;
float longitude = minLongitude + longitudeDelta * i;
Map<String, Float> location = MapUtils.hashMap("latitude", lattitude).map("longitude", longitude);
Map<String, Object> data = new HashMap<String, Object>(2);
data.put("name", String.valueOf(i));
data.put("location", location);
em.create("store", data);
}
app.waitForQueueDrainAndRefreshIndex();
// earth's circumference is 40,075 kilometers. Up it to 50,000kilometers
// just to be save
Query query = Query.fromQL("location within 50000000 of -90, -180" );
query.setLimit( 10 );
int count = 0;
Results results;
double previousDistance = 0d;
do {
results = em.searchCollection(em.getApplicationRef(), "stores", query);
for (Entity entity : results.getEntities()) {
assertEquals(String.valueOf(count), entity.getName());
Object distanceObject = entity.getMetadata("distance");
assertNotNull( distanceObject );
assertTrue( distanceObject instanceof Double );
double distance = (Double)distanceObject;
assertTrue( distance >= previousDistance );
previousDistance = distance;
count++;
}
// set for the next "page"
query.setCursor(results.getCursor());
}
while (results.getCursor() != null);
// check we got back all 500 entities
assertEquals( numEntities, count );
}
@Test
public void testSamePointPaging() throws Exception {
EntityManager em = app.getEntityManager();
assertNotNull(em);
// save objects in a diagonal line from -90 -180 to 90 180
int numEntities = 10;
for (int i = 0; i < numEntities; i++) {
Map<String, Object> data = new HashMap<String, Object>(2);
data.put("name", String.valueOf(i));
setPos(data, 0, 0);
em.create("store", data);
}
app.waitForQueueDrainAndRefreshIndex();
Thread.sleep(2000);
// earth's circumference is 40,075 kilometers. Up it to 50,000kilometers
// just to be save
Query query = Query.fromQL("location within 50000000 of 0, 0" );
query.setLimit( 5 );
int count = 0;
Results results;
double previousDistance = 0d;
do {
results = em.searchCollection(em.getApplicationRef(), "stores", query);
for (Entity entity : results.getEntities()) {
//TODO:can we assert order
final int expected = numEntities - count - 1;
Object distanceObject = entity.getMetadata("distance");
assertNotNull( distanceObject );
assertTrue( distanceObject instanceof Double );
double distance = (Double)distanceObject;
assertTrue( distance >= previousDistance );
previousDistance = distance;
assertEquals(String.valueOf(expected), entity.getName());
count++;
}
// set for the next "page"
query.setCursor(results.getCursor());
}
while (results.getCursor() != null);
// check we got back all 500 entities
assertEquals(numEntities, count);
}
@Test
public void testDistanceByLimit() throws Exception {
EntityManager em = app.getEntityManager();
assertNotNull(em);
// save objects in a diagonal line from -90 -180 to 90 180
int numEntities = 10;
float minLattitude = -90;
float maxLattitude = 90;
float minLongitude = -180;
float maxLongitude = 180;
float lattitudeDelta = (maxLattitude - minLattitude) / numEntities;
float longitudeDelta = (maxLongitude - minLongitude) / numEntities;
for (int i = 0; i < numEntities; i++) {
float lattitude = minLattitude + lattitudeDelta * i;
float longitude = minLongitude + longitudeDelta * i;
Map<String, Float> location = MapUtils.hashMap("latitude", lattitude).map("longitude", longitude);
Map<String, Object> data = new HashMap<String, Object>(2);
data.put("name", String.valueOf(i));
data.put("location", location);
em.create("store", data);
}
app.waitForQueueDrainAndRefreshIndex();
// earth's circumference is 40,075 kilometers. Up it to 50,000kilometers
// just to be save
Query query = Query.fromQL( "location within 50000000 of -90, -180" );
query.setLimit(10);
int count = 0;
do {
Results results = em.searchCollection(em.getApplicationRef(), "stores", query);
double previousDistance = 0d;
for (Entity entity : results.getEntities()) {
assertEquals(String.valueOf(count), entity.getName());
Object distanceObject = entity.getMetadata("distance");
assertNotNull( distanceObject );
assertTrue( distanceObject instanceof Double );
double distance = (Double)distanceObject;
assertTrue( distance >= previousDistance );
previousDistance = distance;
count++;
}
}
while (query.getCursor().isPresent());
// check we got back all 500 entities
assertEquals(numEntities, count);
}
@Test
public void testGeoWithIntersection() throws Exception {
EntityManager em = app.getEntityManager();
assertNotNull( em );
int size = 10;
int min = 5;
int max = 9;
List<Entity> created = new ArrayList<Entity>(size);
for (int i = 0; i < size; i++) {
// save all entities in the same location
Map<String, Object> data = new HashMap<String, Object>(2);
data.put("name", String.valueOf(i));
data.put("index", i);
setPos(data, 0, 0);
Entity e = em.create("store", data);
created.add(e);
}
app.waitForQueueDrainAndRefreshIndex();
int startDelta = size - min;
// String queryString = String.format("select * where location within 100 of 0,
// 0 and index >= %d and index < %d order by index",min, max);
String queryString = String.format(
"select * where index >= %d and index < %d order by index", min, max);
Query query = Query.fromQL(queryString);
Results r;
int count = 0;
do {
r = em.searchCollection(em.getApplicationRef(), "stores", query);
for (Entity e : r.getEntities()) {
assertEquals(created.get(startDelta + count), e);
count++;
}
query.setCursor(r.getCursor());
}
while (r.hasCursor());
assertEquals(startDelta - (size - max), count);
}
@Test
public void testDenseSearch() throws Exception {
EntityManager em = app.getEntityManager();
assertNotNull(em);
// save objects in a diagonal line from -90 -180 to 90 180
int numEntities = 25;
float minLatitude = 48.32455f;
float maxLatitude = 48.46481f;
float minLongitude = 9.89561f;
float maxLongitude = 10.0471f;
float latitudeDelta = (maxLatitude - minLatitude) / numEntities;
float longitudeDelta = (maxLongitude - minLongitude) / numEntities;
for (int i = 0; i < numEntities; i++) {
float latitude = minLatitude + latitudeDelta * i;
float longitude = minLongitude + longitudeDelta * i;
Map<String, Float> location =
MapUtils.hashMap("latitude", latitude).map("longitude", longitude);
Map<String, Object> data = new HashMap<String, Object>(2);
data.put("name", String.valueOf(i));
data.put("location", location);
em.create("store", data);
}
app.waitForQueueDrainAndRefreshIndex();
//do a direct geo iterator test. We need to make sure that we short circuit on the correct tile.
int limit = 8;
long startTime = System.currentTimeMillis();
//now test at the EM level, there should be 0 results.
Query query = Query.fromQL("location within 1000 of 48.38626, 9.94175");
query.setLimit(limit);
Results results = em.searchCollection(em.getApplicationRef(), "stores", query);
assertEquals(0, results.size());
long endTime = System.currentTimeMillis();
logger.info("Runtime took {} milliseconds to search", endTime - startTime);
}
/**
* Load entities for geo queries
* 1. Get an instance of the entity manager
* 2. load test entities
* 3. refresh the index
* 4. return the entity manager
*/
private EntityManager loadGeolocationTestEntities() throws Exception {
logger.info("GeoIT.loadGeolocationTestEntities");
//1. Get an instance of the entity manager
EntityManager em = app.getEntityManager();
assertNotNull(em);
//2. load test entities
for (Map<String, Object> location : LOCATION_PROPERTIES) {
logger.info("Create entity with location '{}'", location.get("name"));
Entity entity = em.create("store", location);
assertNotNull(entity);
}
//3. refresh the index
app.waitForQueueDrainAndRefreshIndex();
//4. return the entity manager
return em;
}
public Map<String, Object> getLocation(double latitude, double longitude) throws Exception {
Map<String, Object> latlong = new LinkedHashMap<String, Object>();
latlong.put("latitude", latitude);
latlong.put("longitude", longitude);
return latlong;
}
public void updatePos(EntityManager em, EntityRef entity, double latitude, double longitude) throws Exception {
Map<String, Object> latlong = new LinkedHashMap<String, Object>();
latlong.put("latitude", latitude);
latlong.put("longitude", longitude);
em.setProperty(entity, "location", latlong);
app.waitForQueueDrainAndRefreshIndex();
}
public void setPos(Map<String, Object> data, double latitude, double longitude) {
Map<String, Object> latlong = new LinkedHashMap<String, Object>();
latlong.put("latitude", latitude);
latlong.put("longitude", longitude);
data.put("location", latlong);
}
}