add 地理位置范围查询

jetlinks-components/elasticsearch-component/src/main/java/org/jetlinks/community/elastic/search/geo/EsGeoFilter.java

@@ -0,0 +1,37 @@
+package org.jetlinks.community.elastic.search.geo;
+
+import lombok.Data;
+import org.elasticsearch.common.geo.GeoPoint;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @author lifang
+ * @version 1.0.0
+ * @ClassName Filter.java
+ * @Description TODO
+ * @createTime 2021年10月25日 13:46:00
+ */
+@Data
+public class EsGeoFilter {
+    private String type;
+    private List<List<Double>> pointsStr;
+    private String fieldName;
+
+    private List<GeoPoint> points;
+
+    public void setPointsStr(List<List<Double>> pointsStr) {
+        this.pointsStr = pointsStr;
+        if(pointsStr!=null&&pointsStr.size()!=0){
+            List<GeoPoint> geoPoints = new LinkedList<>();
+            for (List<Double> pointStr : pointsStr) {
+                GeoPoint point = new GeoPoint();
+                point.reset(pointStr.get(1),pointStr.get(0));
+                geoPoints.add(point);
+            }
+            this.points=geoPoints;
+        }
+    }
+}

jetlinks-components/elasticsearch-component/src/main/java/org/jetlinks/community/elastic/search/service/DefaultElasticSearchService.java

@@ -29,6 +29,7 @@ import org.hswebframework.utils.time.DefaultDateFormatter;
 import org.hswebframework.web.api.crud.entity.PagerResult;
 import org.hswebframework.web.bean.FastBeanCopier;
 import org.jetlinks.community.elastic.search.ElasticRestClient;
+import org.jetlinks.community.elastic.search.geo.EsGeoFilter;
 import org.jetlinks.community.elastic.search.index.ElasticSearchIndexManager;
 import org.jetlinks.community.elastic.search.index.ElasticSearchIndexMetadata;
 import org.jetlinks.community.elastic.search.utils.ElasticSearchConverter;
@@ -133,9 +134,9 @@ public class DefaultElasticSearchService implements ElasticSearchService {
     }
 
     @Override
-    public <T> Mono<PagerResult<T>> queryPager(String[] index, QueryParam queryParam, Function<Map<String, Object>, T> mapper) {
+    public <T> Mono<PagerResult<T>> queryPager(String[] index, QueryParam queryParam, EsGeoFilter filter, Function<Map<String, Object>, T> mapper) {
         return this
-            .doQuery(index, queryParam)
+            .doQuery(index, queryParam,filter)
             .flatMap(tp2 ->
                 convertQueryResult(tp2.getT1(), tp2.getT2(), mapper)
                     .collectList()
@@ -145,6 +146,20 @@ public class DefaultElasticSearchService implements ElasticSearchService {
             .switchIfEmpty(Mono.fromSupplier(PagerResult::empty));
     }
 
+    @Override
+    public <T> Mono<PagerResult<T>> queryPager(String[] index, QueryParam queryParam, Function<Map<String, Object>, T> mapper) {
+//        return this
+//            .doQuery(index, queryParam)
+//            .flatMap(tp2 ->
+//                convertQueryResult(tp2.getT1(), tp2.getT2(), mapper)
+//                    .collectList()
+//                    .filter(CollectionUtils::isNotEmpty)
+//                    .map(list -> PagerResult.of((int) tp2.getT2().getHits().getTotalHits().value, list, queryParam))
+//            )
+//            .switchIfEmpty(Mono.fromSupplier(PagerResult::empty));
+        return this.queryPager(index,queryParam,null,mapper);
+    }
+
     private <T> Flux<T> convertQueryResult(List<ElasticSearchIndexMetadata> indexList,
                                            SearchResponse response,
                                            Function<Map<String, Object>, T> mapper) {
@@ -171,13 +186,13 @@ public class DefaultElasticSearchService implements ElasticSearchService {
     }
 
     private Mono<Tuple2<List<ElasticSearchIndexMetadata>, SearchResponse>> doQuery(String[] index,
-                                                                                   QueryParam queryParam) {
+                                                                                   QueryParam queryParam,EsGeoFilter filter) {
         return indexManager
             .getIndexesMetadata(index)
             .collectList()
             .filter(CollectionUtils::isNotEmpty)
             .flatMap(metadataList -> this
-                .createSearchRequest(queryParam, metadataList)
+                .createSearchRequest(queryParam,filter, metadataList)
                 .flatMap(this::doSearch)
                 .map(response -> Tuples.of(metadataList, response))
             ).onErrorResume(err -> {
@@ -186,6 +201,23 @@ public class DefaultElasticSearchService implements ElasticSearchService {
             });
     }
 
+    private Mono<Tuple2<List<ElasticSearchIndexMetadata>, SearchResponse>> doQuery(String[] index,
+                                                                                   QueryParam queryParam) {
+//        return indexManager
+//            .getIndexesMetadata(index)
+//            .collectList()
+//            .filter(CollectionUtils::isNotEmpty)
+//            .flatMap(metadataList -> this
+//                .createSearchRequest(queryParam, metadataList)
+//                .flatMap(this::doSearch)
+//                .map(response -> Tuples.of(metadataList, response))
+//            ).onErrorResume(err -> {
+//                log.error(err.getMessage(), err);
+//                return Mono.empty();
+//            });
+        return doQuery(index,queryParam,null);
+    }
+
 
     @Override
     public Mono<Long> count(String[] index, QueryParam queryParam) {
@@ -402,9 +434,9 @@ public class DefaultElasticSearchService implements ElasticSearchService {
             .flatMap(list -> createSearchRequest(queryParam, list));
     }
 
-    protected Mono<SearchRequest> createSearchRequest(QueryParam queryParam, List<ElasticSearchIndexMetadata> indexes) {
+    protected Mono<SearchRequest> createSearchRequest(QueryParam queryParam, EsGeoFilter filter,List<ElasticSearchIndexMetadata> indexes) {
 
-        SearchSourceBuilder builder = ElasticSearchConverter.convertSearchSourceBuilder(queryParam, indexes.get(0));
+        SearchSourceBuilder builder = ElasticSearchConverter.convertSearchSourceBuilder(queryParam, filter,indexes.get(0));
         return Flux.fromIterable(indexes)
             .flatMap(index -> getIndexForSearch(index.getIndex()))
             .collectList()
@@ -415,6 +447,20 @@ public class DefaultElasticSearchService implements ElasticSearchService {
                     .types("_doc"));
     }
 
+    protected Mono<SearchRequest> createSearchRequest(QueryParam queryParam, List<ElasticSearchIndexMetadata> indexes) {
+
+        return createSearchRequest(queryParam,null,indexes);
+//        SearchSourceBuilder builder = ElasticSearchConverter.convertSearchSourceBuilder(queryParam, indexes.get(0));
+//        return Flux.fromIterable(indexes)
+//            .flatMap(index -> getIndexForSearch(index.getIndex()))
+//            .collectList()
+//            .map(indexList ->
+//                new SearchRequest(indexList.toArray(new String[0]))
+//                    .source(builder)
+//                    .indicesOptions(indexOptions)
+//                    .types("_doc"));
+    }
+
     protected Mono<QueryBuilder> createQueryBuilder(QueryParam queryParam, String index) {
         return indexManager
             .getIndexMetadata(index)

jetlinks-components/elasticsearch-component/src/main/java/org/jetlinks/community/elastic/search/service/ElasticSearchService.java

@@ -3,6 +3,7 @@ package org.jetlinks.community.elastic.search.service;
 import org.hswebframework.ezorm.core.param.QueryParam;
 import org.hswebframework.web.api.crud.entity.PagerResult;
 import org.hswebframework.web.bean.FastBeanCopier;
+import org.jetlinks.community.elastic.search.geo.EsGeoFilter;
 import org.jetlinks.community.elastic.search.index.ElasticIndex;
 import org.reactivestreams.Publisher;
 import reactor.core.publisher.Flux;
@@ -23,6 +24,12 @@ public interface ElasticSearchService {
         return queryPager(new String[]{index}, queryParam, mapper);
     }
 
+    default <T> Mono<PagerResult<T>> queryPager(String index, QueryParam queryParam, EsGeoFilter filter ,Function<Map<String, Object>, T> mapper) {
+        return queryPager(new String[]{index}, queryParam,filter, mapper);
+    }
+
+    <T> Mono<PagerResult<T>> queryPager(String[] index, QueryParam queryParam,EsGeoFilter filter , Function<Map<String, Object>, T> mapper);
+
     <T> Mono<PagerResult<T>> queryPager(String[] index, QueryParam queryParam, Function<Map<String, Object>, T> mapper);
 
     <T> Flux<T> query(String index, QueryParam queryParam, Function<Map<String, Object>, T> mapper);
@@ -68,6 +75,10 @@ public interface ElasticSearchService {
         return queryPager(index.getIndex(), queryParam, map -> FastBeanCopier.copy(map, type));
     }
 
+    default <T> Mono<PagerResult<T>> queryPager(ElasticIndex index, QueryParam queryParam, EsGeoFilter filter,Class<T> type) {
+        return queryPager(index.getIndex(), queryParam,filter, map -> FastBeanCopier.copy(map, type));
+    }
+
     default <T> Mono<PagerResult<T>> queryPager(ElasticIndex index, QueryParam queryParam, Function<Map<String, Object>, T> mapper) {
         return queryPager(index.getIndex(), queryParam, mapper);
     }

jetlinks-components/elasticsearch-component/src/main/java/org/jetlinks/community/elastic/search/service/reactive/ReactiveElasticSearchService.java

@@ -27,6 +27,7 @@ import org.hswebframework.utils.time.DateFormatter;
 import org.hswebframework.utils.time.DefaultDateFormatter;
 import org.hswebframework.web.api.crud.entity.PagerResult;
 import org.hswebframework.web.bean.FastBeanCopier;
+import org.jetlinks.community.elastic.search.geo.EsGeoFilter;
 import org.jetlinks.community.elastic.search.index.ElasticSearchIndexManager;
 import org.jetlinks.community.elastic.search.index.ElasticSearchIndexMetadata;
 import org.jetlinks.community.elastic.search.service.ElasticSearchService;
@@ -139,8 +140,8 @@ public class ReactiveElasticSearchService implements ElasticSearchService {
     }
 
     @Override
-    public <T> Mono<PagerResult<T>> queryPager(String[] index, QueryParam queryParam, Function<Map<String, Object>, T> mapper) {
-        return this.doQuery(index, queryParam)
+    public <T> Mono<PagerResult<T>> queryPager(String[] index, QueryParam queryParam, EsGeoFilter filter, Function<Map<String, Object>, T> mapper) {
+        return this.doQuery(index, queryParam,filter)
             .flatMap(tp2 -> this
                 .convertQueryResult(tp2.getT1(), tp2.getT2(), mapper)
                 .collectList()
@@ -153,6 +154,22 @@ public class ReactiveElasticSearchService implements ElasticSearchService {
             .switchIfEmpty(Mono.fromSupplier(PagerResult::empty));
     }
 
+    @Override
+    public <T> Mono<PagerResult<T>> queryPager(String[] index, QueryParam queryParam, Function<Map<String, Object>, T> mapper) {
+//        return this.doQuery(index, queryParam)
+//            .flatMap(tp2 -> this
+//                .convertQueryResult(tp2.getT1(), tp2.getT2(), mapper)
+//                .collectList()
+//                .filter(CollectionUtils::isNotEmpty)
+//                .map(list -> PagerResult.of((int) tp2
+//                    .getT2()
+//                    .getHits()
+//                    .getTotalHits().value, list, queryParam))
+//            )
+//            .switchIfEmpty(Mono.fromSupplier(PagerResult::empty));
+        return queryPager(index,queryParam,null,mapper);
+    }
+
     private <T> Flux<T> convertQueryResult(List<ElasticSearchIndexMetadata> indexList,
                                            SearchResponse response,
                                            Function<Map<String, Object>, T> mapper) {
@@ -174,15 +191,14 @@ public class ReactiveElasticSearchService implements ElasticSearchService {
             });
 
     }
-
     private Mono<Tuple2<List<ElasticSearchIndexMetadata>, SearchResponse>> doQuery(String[] index,
-                                                                                   QueryParam queryParam) {
+                                                                                   QueryParam queryParam,EsGeoFilter filter) {
         return indexManager
             .getIndexesMetadata(index)
             .collectList()
             .filter(CollectionUtils::isNotEmpty)
             .flatMap(metadataList -> this
-                .createSearchRequest(queryParam, metadataList)
+                .createSearchRequest(queryParam,filter, metadataList)
                 .flatMap(restClient::searchForPage)
                 .map(response -> Tuples.of(metadataList, response))
             ).onErrorResume(err -> {
@@ -191,6 +207,24 @@ public class ReactiveElasticSearchService implements ElasticSearchService {
             });
     }
 
+
+    private Mono<Tuple2<List<ElasticSearchIndexMetadata>, SearchResponse>> doQuery(String[] index,
+                                                                                   QueryParam queryParam) {
+//        return indexManager
+//            .getIndexesMetadata(index)
+//            .collectList()
+//            .filter(CollectionUtils::isNotEmpty)
+//            .flatMap(metadataList -> this
+//                .createSearchRequest(queryParam, metadataList)
+//                .flatMap(restClient::searchForPage)
+//                .map(response -> Tuples.of(metadataList, response))
+//            ).onErrorResume(err -> {
+//                log.error(err.getMessage(), err);
+//                return Mono.empty();
+//            });
+        return doQuery(index,queryParam,null);
+    }
+
     @Override
     public Mono<Long> count(String[] index, QueryParam queryParam) {
         QueryParam param = queryParam.clone();
@@ -412,9 +446,9 @@ public class ReactiveElasticSearchService implements ElasticSearchService {
             .flatMap(list -> createSearchRequest(queryParam, list));
     }
 
-    protected Mono<SearchRequest> createSearchRequest(QueryParam queryParam, List<ElasticSearchIndexMetadata> indexes) {
+    protected Mono<SearchRequest> createSearchRequest(QueryParam queryParam, EsGeoFilter filter,List<ElasticSearchIndexMetadata> indexes) {
 
-        SearchSourceBuilder builder = ElasticSearchConverter.convertSearchSourceBuilder(queryParam, indexes.get(0));
+        SearchSourceBuilder builder = ElasticSearchConverter.convertSearchSourceBuilder(queryParam, filter,indexes.get(0));
         return Flux.fromIterable(indexes)
             .flatMap(index -> getIndexForSearch(index.getIndex()))
             .collectList()
@@ -424,6 +458,19 @@ public class ReactiveElasticSearchService implements ElasticSearchService {
                     .indicesOptions(indexOptions));
     }
 
+    protected Mono<SearchRequest> createSearchRequest(QueryParam queryParam, List<ElasticSearchIndexMetadata> indexes) {
+
+//        SearchSourceBuilder builder = ElasticSearchConverter.convertSearchSourceBuilder(queryParam, indexes.get(0));
+//        return Flux.fromIterable(indexes)
+//            .flatMap(index -> getIndexForSearch(index.getIndex()))
+//            .collectList()
+//            .map(indexList ->
+//                new SearchRequest(indexList.toArray(new String[0]))
+//                    .source(builder)
+//                    .indicesOptions(indexOptions));
+        return createSearchRequest(queryParam,null,indexes);
+    }
+
     protected Mono<QueryBuilder> createQueryBuilder(QueryParam queryParam, String index) {
         return indexManager
             .getIndexMetadata(index)

jetlinks-components/elasticsearch-component/src/main/java/org/jetlinks/community/elastic/search/utils/ElasticSearchConverter.java

@@ -2,6 +2,7 @@ package org.jetlinks.community.elastic.search.utils;
 
 import org.elasticsearch.search.builder.SearchSourceBuilder;
 import org.hswebframework.ezorm.core.param.QueryParam;
+import org.jetlinks.community.elastic.search.geo.EsGeoFilter;
 import org.jetlinks.community.elastic.search.index.ElasticSearchIndexMetadata;
 import org.jetlinks.core.metadata.Converter;
 import org.jetlinks.core.metadata.DataType;
@@ -19,7 +20,12 @@ public class ElasticSearchConverter {
 
 
     public static SearchSourceBuilder convertSearchSourceBuilder(QueryParam queryParam, ElasticSearchIndexMetadata metadata) {
-        return QueryParamTranslator.convertSearchSourceBuilder(queryParam, metadata);
+//        return QueryParamTranslator.convertSearchSourceBuilder(queryParam, metadata);
+        return convertSearchSourceBuilder(queryParam,null,metadata);
+    }
+
+    public static SearchSourceBuilder convertSearchSourceBuilder(QueryParam queryParam, EsGeoFilter filter,ElasticSearchIndexMetadata metadata) {
+        return QueryParamTranslator.convertSearchSourceBuilder(queryParam, filter,metadata);
     }
 
     public static Map<String, Object> convertDataToElastic(Map<String, Object> data, List<PropertyMetadata> properties) {

jetlinks-components/elasticsearch-component/src/main/java/org/jetlinks/community/elastic/search/utils/QueryParamTranslator.java

@@ -2,15 +2,13 @@ package org.jetlinks.community.elastic.search.utils;
 
 import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
-import org.elasticsearch.index.query.BoolQueryBuilder;
-import org.elasticsearch.index.query.ExistsQueryBuilder;
-import org.elasticsearch.index.query.QueryBuilder;
-import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.index.query.*;
 import org.elasticsearch.search.builder.SearchSourceBuilder;
 import org.elasticsearch.search.sort.SortOrder;
 import org.hswebframework.ezorm.core.param.QueryParam;
 import org.hswebframework.ezorm.core.param.Sort;
 import org.hswebframework.ezorm.core.param.Term;
+import org.jetlinks.community.elastic.search.geo.EsGeoFilter;
 import org.jetlinks.community.elastic.search.index.ElasticSearchIndexMetadata;
 import org.jetlinks.community.elastic.search.parser.DefaultLinkTypeParser;
 import org.jetlinks.core.metadata.DataType;
@@ -76,7 +74,27 @@ public class QueryParamTranslator {
         }
         return queryBuilders;
     }
+
+
     public static SearchSourceBuilder convertSearchSourceBuilder(QueryParam queryParam, ElasticSearchIndexMetadata metadata) {
+//        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
+//        if (queryParam.isPaging()) {
+//            sourceBuilder.from(queryParam.getPageIndex() * queryParam.getPageSize());
+//            sourceBuilder.size(queryParam.getPageSize());
+//        }
+//        for (Sort sort : queryParam.getSorts()) {
+//            if (!StringUtils.isEmpty(sort.getName())) {
+//                sourceBuilder.sort(sort.getName(), SortOrder.fromString(sort.getOrder()));
+//            }
+//        }
+//
+////        GeoPolygonQueryBuilder geoPolygonQueryBuilder = QueryBuilders.geoPolygonQuery();
+////        sourceBuilder.postFilter(geoPolygonQueryBuilder);
+//        return sourceBuilder.query(createQueryBuilder(queryParam,metadata));
+        return convertSearchSourceBuilder(queryParam,null,metadata);
+    }
+
+    public static SearchSourceBuilder convertSearchSourceBuilder(QueryParam queryParam, EsGeoFilter filter,ElasticSearchIndexMetadata metadata) {
         SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
         if (queryParam.isPaging()) {
             sourceBuilder.from(queryParam.getPageIndex() * queryParam.getPageSize());
@@ -87,8 +105,12 @@ public class QueryParamTranslator {
                 sourceBuilder.sort(sort.getName(), SortOrder.fromString(sort.getOrder()));
             }
         }
-
-        return sourceBuilder.query(createQueryBuilder(queryParam,metadata));
+       BoolQueryBuilder queryBuilder = (BoolQueryBuilder) createQueryBuilder(queryParam, metadata);
+        if(filter!=null){
+            GeoPolygonQueryBuilder geoPolygonQueryBuilder = QueryBuilders.geoPolygonQuery(filter.getFieldName(),filter.getPoints());
+            queryBuilder.filter(geoPolygonQueryBuilder);
+        }
+        return sourceBuilder.query(queryBuilder);
     }
 
 }

jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/configuration/GeoIndexInitialize.java

@@ -3,7 +3,6 @@ package org.jetlinks.community.device.configuration;
 import org.jetlinks.community.device.constant.GeoConstant;
 import org.jetlinks.community.elastic.search.index.DefaultElasticSearchIndexMetadata;
 import org.jetlinks.community.elastic.search.index.ElasticSearchIndexManager;
-import org.jetlinks.community.elastic.search.index.strategies.DirectElasticSearchIndexStrategy;
 import org.jetlinks.core.metadata.types.GeoType;
 import org.jetlinks.core.metadata.types.StringType;
 import org.springframework.core.annotation.Order;

jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/constant/GeoConstant.java

@@ -12,5 +12,5 @@ public class GeoConstant {
     public static final String ES_DEVICE_NAME="name";
     public static final String ES_DEVICE_PRODUCT_ID="productId";
     public static final String ES_DEVICE_PRODUCT_NAME="productName";
-    public static final String ES_DEVICE_GEO_POINT="coordinate";
+    public static final String ES_DEVICE_GEO_POINT="location";
 }

jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/dto/DeviceGeoDto.java

@@ -1,9 +1,11 @@
 package org.jetlinks.community.device.dto;
 
+import cn.hutool.core.collection.CollectionUtil;
 import lombok.Data;
 import org.jetlinks.community.device.entity.DeviceInstanceEntity;
+import org.jetlinks.community.device.entity.geo.Geometry;
 import org.jetlinks.core.metadata.types.GeoPoint;
-
+import java.util.*;
 /**
  * @author lifang
  * @version 1.0.0
@@ -20,7 +22,7 @@ public class DeviceGeoDto {
     private String productId;
     private String productName;
 
-    private GeoPoint coordinate;
+    private GeoPoint location;
 
     public static DeviceGeoDto of(DeviceInstanceEntity instanceEntity){
         DeviceGeoDto deviceGeo = new DeviceGeoDto();
@@ -28,7 +30,7 @@ public class DeviceGeoDto {
         deviceGeo.setName(instanceEntity.getName());
         deviceGeo.setProductId(instanceEntity.getProductId());
         deviceGeo.setProductName(instanceEntity.getProductName());
-        deviceGeo.setCoordinate(instanceEntity.getCoordinate());
+        deviceGeo.setLocation(instanceEntity.getLocation());
         return deviceGeo;
     }
 }

jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/entity/DeviceInstanceEntity.java

@@ -9,6 +9,7 @@ import org.hswebframework.web.api.crud.entity.RecordCreationEntity;
 import org.hswebframework.web.crud.generator.Generators;
 import org.hswebframework.web.dict.EnumDict;
 import org.hswebframework.web.validator.CreateGroup;
+import org.jetlinks.community.device.entity.geo.Geometry;
 import org.jetlinks.community.device.enums.DeviceFeature;
 import org.jetlinks.community.device.enums.DeviceState;
 import org.jetlinks.core.device.DeviceConfigKey;
@@ -70,11 +71,11 @@ public class DeviceInstanceEntity extends GenericEntity<String> implements Recor
 
     //todo
     @Comment("地理位置")
-    @Column(name = "coordinate")
+    @Column(name = "location")
     @JsonCodec
     @ColumnType(jdbcType = JDBCType.VARCHAR)
     @Schema(description = "地理位置")
-    private GeoPoint coordinate;
+    private GeoPoint location;
 
     @Comment("其他配置")
     @Column(name = "configuration")

jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/entity/geo/GeoProperty.java

@@ -96,8 +96,8 @@ public  class GeoProperty extends GenericEntity<String> {
         GeoProperty geoProperty = new GeoProperty();
         Geometry geometry = new Geometry();
         String[] split = tag.getValue().split(",");
-        geometry.getCoordinates().add(split[0]);
-        geometry.getCoordinates().add(split[1]);
+//        geometry.getCoordinates().add(split[0]);
+//        geometry.getCoordinates().add(split[1]);
         geometry.setType("Point");
         geoProperty.setId(tag.getId());
 //        geoProperty.setFrom("tag");

jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/entity/geo/Geometry.java

@@ -2,6 +2,7 @@ package org.jetlinks.community.device.entity.geo;
 
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import lombok.Data;
+import org.jetlinks.core.metadata.types.GeoPoint;
 
 import java.io.Serializable;
 import java.util.ArrayList;
@@ -18,5 +19,5 @@ import java.util.List;
 @JsonSerialize
 public class Geometry {
     private String type;
-    private List<Object> coordinates=new ArrayList<>();
+    private List<List<List<Double>>> coordinates=new ArrayList<>();
 }

jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/response/DeviceDetail.java

@@ -7,6 +7,7 @@ import org.apache.commons.collections4.MapUtils;
 import org.jetlinks.community.device.entity.DeviceInstanceEntity;
 import org.jetlinks.community.device.entity.DeviceProductEntity;
 import org.jetlinks.community.device.entity.DeviceTagEntity;
+import org.jetlinks.community.device.entity.geo.Geometry;
 import org.jetlinks.community.device.enums.DeviceState;
 import org.jetlinks.community.device.enums.DeviceType;
 import org.jetlinks.core.Values;
@@ -223,7 +224,7 @@ public class DeviceDetail {
 
     public DeviceDetail with(DeviceInstanceEntity device) {
 
-        setCoordinate(device.getCoordinate());
+        setCoordinate(device.getLocation());
         setId(device.getId());
         setName(device.getName());
         setState(device.getState());

jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/service/DeviceTagsService.java

@@ -68,8 +68,8 @@ public class DeviceTagsService  extends GenericReactiveCrudService<DeviceTagEnti
         GeoProperty geoProperty = new GeoProperty();
         Geometry geometry = new Geometry();
         String[] split = entity.getValue().split(",");
-        geometry.getCoordinates().add(split[0]);
-        geometry.getCoordinates().add(split[1]);
+//        geometry.getCoordinates().add(split[0]);
+//        geometry.getCoordinates().add(split[1]);
         geometry.setType("Point");
         return instanceService.findById(entity.getDeviceId())
             .flatMap(device->{

jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/DeviceInstanceController.java

@@ -8,6 +8,7 @@ import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.Getter;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
+import org.elasticsearch.search.aggregations.bucket.filter.Filter;
 import org.hswebframework.ezorm.rdb.mapping.ReactiveRepository;
 import org.hswebframework.ezorm.rdb.mapping.defaults.SaveResult;
 import org.hswebframework.reactor.excel.ReactorExcel;
@@ -26,6 +27,7 @@ import org.hswebframework.web.id.IDGenerator;
 import org.jetlinks.community.device.configuration.GeoIndexProvider;
 import org.jetlinks.community.device.dto.DeviceGeoDto;
 import org.jetlinks.community.device.entity.*;
+import org.jetlinks.community.device.entity.geo.Geometry;
 import org.jetlinks.community.device.enums.DeviceState;
 import org.jetlinks.community.device.response.DeviceDeployResult;
 import org.jetlinks.community.device.response.DeviceDetail;
@@ -35,6 +37,8 @@ import org.jetlinks.community.device.service.data.DeviceDataService;
 import org.jetlinks.community.device.web.excel.DeviceExcelInfo;
 import org.jetlinks.community.device.web.excel.DeviceWrapper;
 import org.jetlinks.community.device.web.request.AggRequest;
+import org.jetlinks.community.device.web.request.GeoRequestParam;
+import org.jetlinks.community.elastic.search.geo.EsGeoFilter;
 import org.jetlinks.community.elastic.search.service.ElasticSearchService;
 import org.jetlinks.community.io.excel.ImportExportService;
 import org.jetlinks.community.io.utils.FileUtils;
@@ -841,7 +845,7 @@ public class DeviceInstanceController implements
                                    @RequestBody GeoPoint geoPoint) {
         return instanceService.createUpdate()
             .where(DeviceInstanceEntity::getId,deviceId)
-            .set(DeviceInstanceEntity::getCoordinate,geoPoint)
+            .set(DeviceInstanceEntity::getLocation,geoPoint)
             .execute()
             .flatMap(ignore->
                 instanceService.findById(deviceId)
@@ -857,30 +861,30 @@ public class DeviceInstanceController implements
     @SaveAction
     @Operation(summary = "获取设备地理位置信息")
     public Mono<GeoPoint> getGeo(@PathVariable @Parameter(description = "设备ID") String deviceId) {
-        return instanceService.findById(deviceId).map(DeviceInstanceEntity::getCoordinate);
+        return instanceService.findById(deviceId).map(DeviceInstanceEntity::getLocation);
     }
 
 
     /**
      * 分页查询设备信息
-     * @param query
-     * @param shapes
+     * @param param
+     * @param hasGeo
      * @return
      */
-    @GetMapping("/geo/_query/{bool}")
-    public Mono<PagerResult<DeviceInstanceEntity>> queryPagergeo(QueryParamEntity query,@PathVariable("bool") boolean s) {
-        if(s){
+    @PostMapping("/geo/_query/{hasGeo}")
+    public Mono<PagerResult<DeviceInstanceEntity>> queryPageGeo(@RequestBody GeoRequestParam param, @PathVariable("hasGeo") boolean hasGeo) {
+        if(hasGeo){
 //            /**
 //             * 没有查询区域
 //             */
-            query.setIncludes(CollectionUtil.newHashSet("id","name","coordinate","productId","productName"));
-            return instanceService.queryPager(query);
+            param.getQuery().setIncludes(CollectionUtil.newHashSet("id","name","location","productId","productName"));
+            return instanceService.queryPager(param.getQuery());
         }else {
             /**
              * 查询区域
              * es查询
              */
-             return elasticSearchService.queryPager(GeoIndexProvider.GEO,query,DeviceInstanceEntity.class);
+              return elasticSearchService.queryPager(GeoIndexProvider.GEO,param.getQuery(),param.getFilter(),DeviceInstanceEntity.class);
         }
     }
 }

jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/GeoController.java

@@ -55,7 +55,7 @@ public class GeoController  implements ReactiveServiceCrudController<GeoProperty
 
     @PostMapping("/_search/geo.json")
     public Mono<?> search(@RequestBody GeoRequestParam param){
-        return geoService.queryPager(param.getFilter())
+        return geoService.queryPager(param.getQuery())
             .map(PagerResult::getData)
             .zipWith(Mono.just(new GeoPayload()))
             .doOnNext(tp2->{

jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/request/GeoRequestParam.java

@@ -2,6 +2,7 @@ package org.jetlinks.community.device.web.request;
 
 import lombok.Data;
 import org.hswebframework.web.api.crud.entity.QueryParamEntity;
+import org.jetlinks.community.elastic.search.geo.EsGeoFilter;
 import org.jetlinks.core.metadata.types.GeoShape;
 
 import java.io.Serializable;
@@ -15,6 +16,6 @@ import java.io.Serializable;
  */
 @Data
 public class GeoRequestParam implements Serializable {
-    QueryParamEntity filter;
-    GeoShape shape;
+    QueryParamEntity query;
+    EsGeoFilter filter;
 }