Merge branch 'geo-view' into 'master'

Add geo view API

See merge request entgra/carbon-device-mgt!775

components/device-mgt/org.wso2.carbon.device.mgt.api/src/main/java/org/wso2/carbon/device/mgt/jaxrs/beans/GeoCluster.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2018-2021, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
+ *
+ * Entgra (Pvt) Ltd. 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.wso2.carbon.device.mgt.jaxrs.beans;
+
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCoordinate;
+
+public class GeoCluster {
+    private final GeoCoordinate coordinates;
+    private final GeoCoordinate southWestBound;
+    private final GeoCoordinate northEastBound;
+    private final long count;
+    private final String geohashPrefix;
+    private final String deviceIdentification;
+    private final String deviceName;
+    private final String deviceType;
+    private final String lastSeen;
+
+    public GeoCluster(GeoCoordinate coordinates, GeoCoordinate southWestBound, GeoCoordinate northEastBound,
+                      long count, String geohashPrefix, String deviceIdentification, String deviceName,
+                      String deviceType, String lastSeen) {
+        this.coordinates = coordinates;
+        this.southWestBound = southWestBound;
+        this.northEastBound = northEastBound;
+        this.count = count;
+        this.geohashPrefix = geohashPrefix;
+        this.deviceIdentification = deviceIdentification;
+        this.deviceName = deviceName;
+        this.deviceType = deviceType;
+        this.lastSeen = lastSeen;
+    }
+
+    public String getGeohashPrefix() {
+        return geohashPrefix;
+    }
+
+    public long getCount() {
+        return count;
+    }
+
+    public GeoCoordinate getCoordinates() {
+        return coordinates;
+    }
+
+    public GeoCoordinate getSouthWestBound() {
+        return southWestBound;
+    }
+
+    public GeoCoordinate getNorthEastBound() {
+        return northEastBound;
+    }
+
+    public String getDeviceIdentification() {
+        return deviceIdentification;
+    }
+
+    public String getDeviceName() {
+        return deviceName;
+    }
+
+    public String getDeviceType() {
+        return deviceType;
+    }
+
+    public String getLastSeen() {
+        return lastSeen;
+    }
+
+}

components/device-mgt/org.wso2.carbon.device.mgt.api/src/main/java/org/wso2/carbon/device/mgt/jaxrs/service/api/GeoLocationBasedService.java

@@ -16,7 +16,6 @@
  * under the License.
  */
 
-
 package org.wso2.carbon.device.mgt.jaxrs.service.api;
 
 import io.swagger.annotations.Api;
@@ -32,6 +31,7 @@ import io.swagger.annotations.SwaggerDefinition;
 import io.swagger.annotations.Tag;
 import org.wso2.carbon.apimgt.annotations.api.Scope;
 import org.wso2.carbon.apimgt.annotations.api.Scopes;
+import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
 import org.wso2.carbon.device.mgt.common.geo.service.Alert;
 import org.wso2.carbon.device.mgt.jaxrs.beans.ErrorResponse;
 import org.wso2.carbon.device.mgt.jaxrs.beans.GeofenceWrapper;
@@ -41,7 +41,6 @@ import javax.validation.Valid;
 import javax.validation.constraints.Size;
 import javax.ws.rs.Consumes;
 import javax.ws.rs.DELETE;
-import javax.ws.rs.DefaultValue;
 import javax.ws.rs.GET;
 import javax.ws.rs.POST;
 import javax.ws.rs.PUT;
@@ -51,7 +50,7 @@ import javax.ws.rs.Produces;
 import javax.ws.rs.QueryParam;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.Response;
-import java.util.ArrayList;
+import java.util.List;
 
 @SwaggerDefinition(
         info = @Info(
@@ -208,6 +207,7 @@ public interface GeoLocationBasedService {
                     message = "Internal Server Error. \n Error on retrieving stats",
                     response = Response.class)
     })
+    @Deprecated
     Response getGeoDeviceLocations(
             @ApiParam(
                     name = "deviceType",
@@ -244,6 +244,124 @@ public interface GeoLocationBasedService {
                     defaultValue ="2")
             @QueryParam("zoom") int zoom);
 
+    @Path("stats/geo-view")
+    @GET
+    @Consumes("application/json")
+    @Produces("application/json")
+    @ApiOperation(
+            consumes = "application/json",
+            produces = "application/json",
+            httpMethod = "GET",
+            value = "Getting geo view of devices",
+            notes = "Get the details of the devices that are within the map. The map area is enclosed with four " +
+                    "coordinates in the shape of a square or rectangle. This is done by defining two points of the " +
+                    "map. The other two points are automatically created using the given points. " +
+                    "You can define the zoom level or scale of the map too.",
+            response = Response.class,
+            tags = "Geo Service Management",
+            extensions = {
+                    @Extension(properties = {
+                            @ExtensionProperty(name = Constants.SCOPE, value = "perm:geo-service:analytics-view")
+                    })
+            }
+    )
+    @ApiResponses(value = {
+            @ApiResponse(
+                    code = 200,
+                    message = "OK.",
+                    response = Response.class,
+                    responseHeaders = {
+                            @ResponseHeader(
+                                    name = "Content-Type",
+                                    description = "The content type of the body"),
+                            @ResponseHeader(
+                                    name = "Last-Modified",
+                                    description = "Date and time the resource was last modified.\n" +
+                                            "Used by caches, or in conditional requests."),
+                    }),
+            @ApiResponse(
+                    code = 400,
+                    message = "Bad Request. \n Invalid parameters found.",
+                    response = Response.class),
+            @ApiResponse(
+                    code = 401,
+                    message = "Unauthorized. \n Unauthorized request."),
+            @ApiResponse(
+                    code = 500,
+                    message = "Internal Server Error. \n Error on retrieving stats",
+                    response = Response.class)
+    })
+    Response getGeoDeviceView(
+            @ApiParam(
+                    name = "minLat",
+                    value = "Define the minimum latitude of the geofence.",
+                    required = true,
+                    defaultValue ="79.85213577747345")
+            @QueryParam("minLat") double minLat,
+            @ApiParam(
+                    name = "maxLat",
+                    value = "Define the maximum latitude of the geofence.",
+                    required = true,
+                    defaultValue ="79.85266149044037")
+            @QueryParam("maxLat") double maxLat,
+            @ApiParam(
+                    name = "minLong",
+                    value = "Define the minimum longitude of the geofence.",
+                    required = true,
+                    defaultValue ="6.909673257977737")
+            @QueryParam("minLong") double minLong,
+            @ApiParam(
+                    name = "maxLong",
+                    value = "Define the maximum longitude of the geofence",
+                    required = true,
+                    defaultValue ="6.909673257977737")
+            @QueryParam("maxLong") double maxLong,
+            @ApiParam(
+                    name = "zoom",
+                    value = "Define the level to zoom or scale the map. You can define any value between 1 to 14.",
+                    required = true,
+                    defaultValue ="2")
+            @QueryParam("zoom") int zoom,
+            @ApiParam(
+                    name = "deviceType",
+                    value = "Optional Device type name.")
+            @QueryParam("deviceType") List<String> deviceTypes,
+            @ApiParam(
+                    name = "deviceIdentifier",
+                    value = "Optional Device Identifier.")
+            @QueryParam("deviceIdentifier") List<String> deviceIdentifiers,
+            @ApiParam(
+                    name = "status",
+                    value = "Optional Device status.")
+            @QueryParam("status") List<EnrolmentInfo.Status> statuses,
+            @ApiParam(
+                    name = "ownership",
+                    value = "Optional Device ownership.")
+            @QueryParam("ownership") List<String> ownerships,
+            @ApiParam(
+                    name = "owner",
+                    value = "Optional Device owner.")
+            @QueryParam("owner") List<String> owners,
+            @ApiParam(
+                    name = "noClusters",
+                    value = "Optional include devices only.")
+            @QueryParam("noClusters") boolean noClusters,
+            @ApiParam(
+                    name = "createdBefore",
+                    value = "Optional Device created before timestamp.")
+            @QueryParam("createdBefore") long createdBefore,
+            @ApiParam(
+                    name = "createdAfter",
+                    value = "Optional Device created after timestamp..")
+            @QueryParam("createdAfter") long createdAfter,
+            @ApiParam(
+                    name = "updatedBefore",
+                    value = "Optional Device updated before timestamp.")
+            @QueryParam("updatedBefore") long updatedBefore,
+            @ApiParam(
+                    name = "updatedAfter",
+                    value = "Optional Device updated after timestamp.")
+            @QueryParam("updatedAfter") long updatedAfter);
 
     /**
      * Create Geo alerts

components/device-mgt/org.wso2.carbon.device.mgt.api/src/main/java/org/wso2/carbon/device/mgt/jaxrs/service/impl/GeoLocationBasedServiceImpl.java

@@ -38,6 +38,7 @@ import org.wso2.carbon.device.mgt.common.Device;
 import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
 import org.wso2.carbon.device.mgt.common.DeviceManagementConstants;
 import org.wso2.carbon.device.mgt.common.DeviceManagementConstants.GeoServices;
+import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
 import org.wso2.carbon.device.mgt.common.PaginationRequest;
 import org.wso2.carbon.device.mgt.common.PaginationResult;
 import org.wso2.carbon.device.mgt.common.authorization.DeviceAccessAuthorizationException;
@@ -47,13 +48,14 @@ import org.wso2.carbon.device.mgt.common.exceptions.DeviceManagementException;
 import org.wso2.carbon.device.mgt.common.geo.service.Alert;
 import org.wso2.carbon.device.mgt.common.geo.service.AlertAlreadyExistException;
 import org.wso2.carbon.device.mgt.common.geo.service.Event;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCluster;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCoordinate;
 import org.wso2.carbon.device.mgt.common.geo.service.GeoFence;
 import org.wso2.carbon.device.mgt.common.geo.service.GeoLocationBasedServiceException;
 import org.wso2.carbon.device.mgt.common.geo.service.GeoLocationProviderService;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoQuery;
 import org.wso2.carbon.device.mgt.common.geo.service.GeofenceData;
 import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroupConstants;
-import org.wso2.carbon.device.mgt.core.geo.GeoCluster;
-import org.wso2.carbon.device.mgt.core.geo.geoHash.GeoCoordinate;
 import org.wso2.carbon.device.mgt.core.geo.geoHash.geoHashStrategy.GeoHashLengthStrategy;
 import org.wso2.carbon.device.mgt.core.geo.geoHash.geoHashStrategy.ZoomGeoHashLengthStrategy;
 import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
@@ -81,7 +83,10 @@ import javax.ws.rs.Produces;
 import javax.ws.rs.QueryParam;
 import javax.ws.rs.core.Response;
 import java.io.IOException;
+import java.text.SimpleDateFormat;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -91,7 +96,7 @@ import java.util.Map;
  */
 public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
 
-    private static Log log = LogFactory.getLog(GeoLocationBasedServiceImpl.class);
+    private static final Log log = LogFactory.getLog(GeoLocationBasedServiceImpl.class);
 
     @Path("stats/{deviceType}/{deviceId}")
     @GET
@@ -155,6 +160,7 @@ public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
     @GET
     @Consumes("application/json")
     @Produces("application/json")
+    @Deprecated
     public Response getGeoDeviceLocations(
             @QueryParam("deviceType") String deviceType,
             @QueryParam("minLat") double minLat,
@@ -162,6 +168,64 @@ public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
             @QueryParam("minLong") double minLong,
             @QueryParam("maxLong") double maxLong,
             @QueryParam("zoom") int zoom) {
+        GeoHashLengthStrategy geoHashLengthStrategy = new ZoomGeoHashLengthStrategy();
+        GeoCoordinate southWest = new GeoCoordinate(minLat, minLong);
+        GeoCoordinate northEast = new GeoCoordinate(maxLat, maxLong);
+        int geohashLength = geoHashLengthStrategy.getGeohashLength(southWest, northEast, zoom);
+        DeviceManagementProviderService deviceManagementService = DeviceMgtAPIUtils.getDeviceManagementService();
+        GeoQuery geoQuery = new GeoQuery(southWest, northEast, geohashLength);
+        if (deviceType != null) {
+            geoQuery.setDeviceTypes(Collections.singletonList(deviceType));
+        }
+        List<org.wso2.carbon.device.mgt.jaxrs.beans.GeoCluster> geoClusters = new ArrayList<>();
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S");
+        try {
+            List<GeoCluster> newClusters = deviceManagementService.findGeoClusters(geoQuery);
+            org.wso2.carbon.device.mgt.jaxrs.beans.GeoCluster geoCluster;
+            String deviceIdentification = null;
+            String deviceName = null;
+            String lastSeen = null;
+            for (GeoCluster gc : newClusters) {
+                if (gc.getDevice() != null) {
+                    deviceIdentification = gc.getDevice().getDeviceIdentifier();
+                    deviceName = gc.getDevice().getName();
+                    deviceType = gc.getDevice().getType();
+                    lastSeen = simpleDateFormat.format(new Date(gc.getDevice()
+                            .getEnrolmentInfo().getDateOfLastUpdate()));
+                }
+                geoCluster = new org.wso2.carbon.device.mgt.jaxrs.beans.GeoCluster(gc.getCoordinates(),
+                        gc.getSouthWestBound(), gc.getNorthEastBound(), gc.getCount(), gc.getGeohashPrefix(),
+                        deviceIdentification, deviceName, deviceType, lastSeen);
+                geoClusters.add(geoCluster);
+            }
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while retrieving geo clusters query: " + new Gson().toJson(geoQuery);
+            log.error(msg, e);
+            return Response.status(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode()).build();
+        }
+        return Response.ok().entity(geoClusters).build();
+    }
+
+    @Path("stats/geo-view")
+    @GET
+    @Consumes("application/json")
+    @Produces("application/json")
+    public Response getGeoDeviceView(
+            @QueryParam("minLat") double minLat,
+            @QueryParam("maxLat") double maxLat,
+            @QueryParam("minLong") double minLong,
+            @QueryParam("maxLong") double maxLong,
+            @QueryParam("zoom") int zoom,
+            @QueryParam("deviceType") List<String> deviceTypes,
+            @QueryParam("deviceIdentifier") List<String> deviceIdentifiers,
+            @QueryParam("status") List<EnrolmentInfo.Status> statuses,
+            @QueryParam("ownership") List<String> ownerships,
+            @QueryParam("owner") List<String> owners,
+            @QueryParam("noClusters") boolean noClusters,
+            @QueryParam("createdBefore") long createdBefore,
+            @QueryParam("createdAfter") long createdAfter,
+            @QueryParam("updatedBefore") long updatedBefore,
+            @QueryParam("updatedAfter") long updatedAfter) {
 
         GeoHashLengthStrategy geoHashLengthStrategy = new ZoomGeoHashLengthStrategy();
         GeoCoordinate southWest = new GeoCoordinate(minLat, minLong);
@@ -169,15 +233,25 @@ public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
         int geohashLength = geoHashLengthStrategy.getGeohashLength(southWest, northEast, zoom);
         DeviceManagementProviderService deviceManagementService = DeviceMgtAPIUtils.getDeviceManagementService();
         List<GeoCluster> geoClusters;
+        GeoQuery geoQuery = new GeoQuery(southWest, northEast, geohashLength);
+        geoQuery.setDeviceTypes(deviceTypes);
+        geoQuery.setDeviceIdentifiers(deviceIdentifiers);
+        geoQuery.setStatuses(statuses);
+        geoQuery.setOwners(owners);
+        geoQuery.setOwnerships(ownerships);
+        geoQuery.setNoClusters(noClusters);
+        geoQuery.setCreatedBefore(createdBefore);
+        geoQuery.setCreatedAfter(createdAfter);
+        geoQuery.setUpdatedBefore(updatedBefore);
+        geoQuery.setUpdatedAfter(updatedAfter);
         try {
-            geoClusters = deviceManagementService.findGeoClusters(deviceType, southWest, northEast, geohashLength);
+            geoClusters = deviceManagementService.findGeoClusters(geoQuery);
         } catch (DeviceManagementException e) {
-            String msg = "Error occurred while retrieving geo clusters ";
+            String msg = "Error occurred while retrieving geo clusters for query: " + new Gson().toJson(geoQuery);
             log.error(msg, e);
             return Response.status(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode()).build();
         }
         return Response.ok().entity(geoClusters).build();
-
     }
 
     @Path("alerts/{alertType}/{deviceType}/{deviceId}")

components/device-mgt/org.wso2.carbon.device.mgt.api/src/test/java/org/wso2/carbon/device/mgt/jaxrs/service/impl/GeoLocationBasedServiceImplTest.java

@@ -7,8 +7,9 @@ import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 import org.wso2.carbon.context.PrivilegedCarbonContext;
 import org.wso2.carbon.device.mgt.common.exceptions.DeviceManagementException;
-import org.wso2.carbon.device.mgt.core.geo.GeoCluster;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCluster;
-import org.wso2.carbon.device.mgt.core.geo.geoHash.GeoCoordinate;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCoordinate;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoQuery;
 import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
 import org.wso2.carbon.device.mgt.jaxrs.service.api.GeoLocationBasedService;
 
@@ -33,8 +34,9 @@ public class GeoLocationBasedServiceImplTest {
     @Test(description = "This method tests the behaviour of getGeoDeviceLocations when there are no devices" +
             "in the given map boundaries")
     public void testGetGeoDeviceLocations1() throws DeviceManagementException {
+        GeoQuery geoQuery = new GeoQuery(Mockito.any(GeoCoordinate.class), Mockito.any(GeoCoordinate.class), Mockito.anyInt());
         Mockito.doReturn(new ArrayList<GeoCluster>()).when(deviceManagementProviderService)
-                .findGeoClusters(null, Mockito.any(GeoCoordinate.class), Mockito.any(GeoCoordinate.class), Mockito.anyInt());
+                .findGeoClusters(geoQuery);
         Response response = geoLocationBasedService.getGeoDeviceLocations(null, 0.4, 15, 75.6,
                 90.1, 6);
         Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
@@ -47,12 +49,14 @@ public class GeoLocationBasedServiceImplTest {
         List<GeoCluster> geoClusters = new ArrayList<>();
         geoClusters.add(new GeoCluster(new GeoCoordinate(1.5, 80.7),
                 new GeoCoordinate(1.1, 79.5), new GeoCoordinate(1.9, 82.1), 3,
-                "tb32", "aegtew234", "test1", "android", "1234"));
+                "tb32", null));
         geoClusters.add(new GeoCluster(new GeoCoordinate(10.2, 86.1),
                 new GeoCoordinate(9.8, 84.7), new GeoCoordinate(11.1, 88.1), 4,
-                "t1gd", "swerty12s", "t2test", "android", "1234"));
+                "t1gd", null));
+
+        GeoQuery geoQuery = new GeoQuery(Mockito.any(GeoCoordinate.class), Mockito.any(GeoCoordinate.class), Mockito.anyInt());
         Mockito.doReturn(geoClusters).when(deviceManagementProviderService)
-                .findGeoClusters(null, Mockito.any(GeoCoordinate.class), Mockito.any(GeoCoordinate.class), Mockito.anyInt());
+                .findGeoClusters(geoQuery);
         Response response = geoLocationBasedService.getGeoDeviceLocations(null, 0.4, 15, 75.6,
                 90.1, 6);
         Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),

components/device-mgt/org.wso2.carbon.device.mgt.common/src/main/java/org/wso2/carbon/device/mgt/common/geo/service/GeoCluster.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2018-2021, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
+ *
+ * Entgra (Pvt) Ltd. 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.wso2.carbon.device.mgt.common.geo.service;
+
+import org.wso2.carbon.device.mgt.common.Device;
+
+public class GeoCluster {
+
+    private final GeoCoordinate coordinates;
+    private final GeoCoordinate southWestBound;
+    private final GeoCoordinate northEastBound;
+    private final long count;
+    private final String geohashPrefix;
+    private final Device device;
+
+    public GeoCluster(GeoCoordinate coordinates, GeoCoordinate southWestBound, GeoCoordinate northEastBound,
+                      long count, String geohashPrefix, Device device) {
+        this.coordinates = coordinates;
+        this.southWestBound = southWestBound;
+        this.northEastBound = northEastBound;
+        this.count = count;
+        this.geohashPrefix = geohashPrefix;
+        this.device = device;
+    }
+
+    public String getGeohashPrefix() {
+        return geohashPrefix;
+    }
+
+    public long getCount() {
+        return count;
+    }
+
+    public GeoCoordinate getCoordinates() {
+        return coordinates;
+    }
+
+    public GeoCoordinate getSouthWestBound() {
+        return southWestBound;
+    }
+
+    public GeoCoordinate getNorthEastBound() {
+        return northEastBound;
+    }
+
+    public Device getDevice() {
+        return device;
+    }
+
+}

components/device-mgt/org.wso2.carbon.device.mgt.common/src/main/java/org/wso2/carbon/device/mgt/common/geo/service/GeoCoordinate.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2018-2021, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
+ *
+ * Entgra (Pvt) Ltd. 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.wso2.carbon.device.mgt.common.geo.service;
+
+public class GeoCoordinate {
+
+    private final double latitude;
+    private final double longitude;
+
+    public GeoCoordinate(double latitude, double longitude) {
+        this.latitude = latitude;
+        this.longitude = longitude;
+    }
+
+    public double getLatitude() {
+        return latitude;
+    }
+
+    public double getLongitude() {
+        return longitude;
+    }
+
+}

components/device-mgt/org.wso2.carbon.device.mgt.common/src/main/java/org/wso2/carbon/device/mgt/common/geo/service/GeoQuery.java

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2018-2021, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
+ *
+ * Entgra (Pvt) Ltd. 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.wso2.carbon.device.mgt.common.geo.service;
+
+import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
+
+import java.util.List;
+
+public class GeoQuery {
+
+    private final GeoCoordinate southWest;
+    private final GeoCoordinate northEast;
+    private final int geohashLength;
+    private List<String> deviceTypes;
+    private List<String> deviceIdentifiers;
+    private List<EnrolmentInfo.Status> statuses;
+    private List<String> ownerships;
+    private List<String> owners;
+    private boolean noClusters;
+    private long createdBefore;
+    private long createdAfter;
+    private long updatedBefore;
+    private long updatedAfter;
+
+    public GeoQuery(GeoCoordinate southWest, GeoCoordinate northEast, int geohashLength) {
+        this.southWest = southWest;
+        this.northEast = northEast;
+        this.geohashLength = geohashLength;
+    }
+
+    public GeoCoordinate getSouthWest() {
+        return southWest;
+    }
+
+    public GeoCoordinate getNorthEast() {
+        return northEast;
+    }
+
+    public int getGeohashLength() {
+        return geohashLength;
+    }
+
+    public List<String> getDeviceTypes() {
+        return deviceTypes;
+    }
+
+    public void setDeviceTypes(List<String> deviceTypes) {
+        this.deviceTypes = deviceTypes;
+    }
+
+    public List<String> getDeviceIdentifiers() {
+        return deviceIdentifiers;
+    }
+
+    public void setDeviceIdentifiers(List<String> deviceIdentifiers) {
+        this.deviceIdentifiers = deviceIdentifiers;
+    }
+
+    public List<EnrolmentInfo.Status> getStatuses() {
+        return statuses;
+    }
+
+    public void setStatuses(List<EnrolmentInfo.Status> statuses) {
+        this.statuses = statuses;
+    }
+
+    public List<String> getOwnerships() {
+        return ownerships;
+    }
+
+    public void setOwnerships(List<String> ownerships) {
+        this.ownerships = ownerships;
+    }
+
+    public List<String> getOwners() {
+        return owners;
+    }
+
+    public void setOwners(List<String> owners) {
+        this.owners = owners;
+    }
+
+    public boolean isNoClusters() {
+        return noClusters;
+    }
+
+    public void setNoClusters(boolean noClusters) {
+        this.noClusters = noClusters;
+    }
+
+    public long getCreatedBefore() {
+        return createdBefore;
+    }
+
+    public void setCreatedBefore(long createdBefore) {
+        this.createdBefore = createdBefore;
+    }
+
+    public long getCreatedAfter() {
+        return createdAfter;
+    }
+
+    public void setCreatedAfter(long createdAfter) {
+        this.createdAfter = createdAfter;
+    }
+
+    public long getUpdatedBefore() {
+        return updatedBefore;
+    }
+
+    public void setUpdatedBefore(long updatedBefore) {
+        this.updatedBefore = updatedBefore;
+    }
+
+    public long getUpdatedAfter() {
+        return updatedAfter;
+    }
+
+    public void setUpdatedAfter(long updatedAfter) {
+        this.updatedAfter = updatedAfter;
+    }
+
+}

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/dao/DeviceDAO.java

@@ -46,9 +46,10 @@ import org.wso2.carbon.device.mgt.common.configuration.mgt.DevicePropertyInfo;
 import org.wso2.carbon.device.mgt.common.device.details.DeviceData;
 import org.wso2.carbon.device.mgt.common.device.details.DeviceLocationHistorySnapshot;
 import org.wso2.carbon.device.mgt.common.device.details.DeviceMonitoringData;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoQuery;
 import org.wso2.carbon.device.mgt.core.dto.DeviceType;
-import org.wso2.carbon.device.mgt.core.geo.GeoCluster;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCluster;
-import org.wso2.carbon.device.mgt.core.geo.geoHash.GeoCoordinate;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCoordinate;
 
 import java.sql.SQLException;
 import java.util.Date;
@@ -555,14 +556,11 @@ public interface DeviceDAO {
      * This method is used to retrieve the details of geoclusters formed relatively to the zoom level and map
      * boundaries.
      *
-     * @param deviceType Optional device type name.
+     * @param geoQuery  the query to determine the geo data.
-     * @param southWest  the coordinates of southWest corner of the map.
+     * @param tenantId  tenant id.
-     * @param northEast  the coordinates of northEast corner of the map.
-     * @param tenantId   tenant id.
      * @return returns a list of enrolment info objects.
      */
-    List<GeoCluster> findGeoClusters(String deviceType, GeoCoordinate southWest, GeoCoordinate northEast,
+    List<GeoCluster> findGeoClusters(GeoQuery geoQuery, int tenantId) throws DeviceManagementDAOException;
-                                     int geohashLength,int tenantId) throws DeviceManagementDAOException;
 
     /**
      * This method is used to identify whether given device ids are exist or not.

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/dao/impl/AbstractDeviceDAOImpl.java

@@ -48,13 +48,14 @@ import org.wso2.carbon.device.mgt.common.configuration.mgt.DevicePropertyInfo;
 import org.wso2.carbon.device.mgt.common.device.details.DeviceData;
 import org.wso2.carbon.device.mgt.common.device.details.DeviceLocationHistorySnapshot;
 import org.wso2.carbon.device.mgt.common.device.details.DeviceMonitoringData;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoQuery;
 import org.wso2.carbon.device.mgt.core.dao.DeviceDAO;
 import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOException;
 import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOFactory;
 import org.wso2.carbon.device.mgt.core.dao.util.DeviceManagementDAOUtil;
 import org.wso2.carbon.device.mgt.core.dto.DeviceType;
-import org.wso2.carbon.device.mgt.core.geo.GeoCluster;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCluster;
-import org.wso2.carbon.device.mgt.core.geo.geoHash.GeoCoordinate;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCoordinate;
 
 import java.sql.Connection;
 import java.sql.PreparedStatement;
@@ -64,6 +65,7 @@ import java.sql.Statement;
 import java.sql.Timestamp;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
@@ -1850,62 +1852,161 @@ public abstract class AbstractDeviceDAOImpl implements DeviceDAO {
         return tenants;
     }
 
-    public List<GeoCluster> findGeoClusters(String deviceType, GeoCoordinate southWest, GeoCoordinate northEast,
+    public List<GeoCluster> findGeoClusters(GeoQuery geoQuery, int tenantId) throws DeviceManagementDAOException {
-                                            int geohashLength, int tenantId) throws DeviceManagementDAOException {
         Connection conn;
         PreparedStatement stmt = null;
         ResultSet rs = null;
         List<GeoCluster> geoClusters = new ArrayList<>();
         try {
             conn = this.getConnection();
-            String sql = "SELECT AVG(DEVICE_LOCATION.LATITUDE) AS LATITUDE,AVG(DEVICE_LOCATION.LONGITUDE) AS LONGITUDE," +
+            String sql = "SELECT AVG(DEVICE_LOCATION.LATITUDE) AS LATITUDE, " +
-                    " MIN(DEVICE_LOCATION.LATITUDE) AS MIN_LATITUDE, MAX(DEVICE_LOCATION.LATITUDE) AS MAX_LATITUDE," +
+                    "AVG(DEVICE_LOCATION.LONGITUDE) AS LONGITUDE, " +
-                    " MIN(DEVICE_LOCATION.LONGITUDE) AS MIN_LONGITUDE," +
+                    "MIN(DEVICE_LOCATION.LATITUDE) AS MIN_LATITUDE,  " +
-                    " MAX(DEVICE_LOCATION.LONGITUDE) AS MAX_LONGITUDE," +
+                    "MAX(DEVICE_LOCATION.LATITUDE) AS MAX_LATITUDE, " +
-                    " SUBSTRING(DEVICE_LOCATION.GEO_HASH,1,?) AS GEOHASH_PREFIX, COUNT(*) AS COUNT," +
+                    "MIN(DEVICE_LOCATION.LONGITUDE) AS MIN_LONGITUDE, " +
-                    " MIN(DEVICE.DEVICE_IDENTIFICATION) AS DEVICE_IDENTIFICATION," +
+                    "MAX(DEVICE_LOCATION.LONGITUDE) AS MAX_LONGITUDE, " +
-                    " MIN(DEVICE.NAME) AS NAME," +
+                    "SUBSTRING(DEVICE_LOCATION.GEO_HASH,1,?) AS GEOHASH_PREFIX,  " +
-                    " MIN(DEVICE_TYPE.NAME) AS TYPE, " +
+                    "COUNT(DEVICE_LOCATION.ID) AS COUNT, " +
-                    " MIN(DEVICE.LAST_UPDATED_TIMESTAMP) AS LAST_UPDATED_TIMESTAMP " +
+                    "MIN(DEVICE.ID) AS DEVICE_ID, " +
-                    "FROM DM_DEVICE_LOCATION AS DEVICE_LOCATION,DM_DEVICE AS DEVICE, DM_DEVICE_TYPE AS DEVICE_TYPE " +
+                    "MIN(DEVICE.NAME) AS DEVICE_NAME, " +
-                    "WHERE DEVICE_LOCATION.LATITUDE BETWEEN ? AND ? AND " +
+                    "MIN(DEVICE.DESCRIPTION) AS DESCRIPTION, " +
-                    "DEVICE_LOCATION.LONGITUDE BETWEEN ? AND ? AND " +
+                    "MIN(DEVICE_TYPE.NAME) AS DEVICE_TYPE, " +
-                    "DEVICE.TENANT_ID=? AND " +
+                    "MIN(DEVICE.DEVICE_IDENTIFICATION) AS DEVICE_IDENTIFICATION, " +
-                    "DEVICE.ID=DEVICE_LOCATION.DEVICE_ID  AND DEVICE.DEVICE_TYPE_ID=DEVICE_TYPE.ID";
+                    "MIN(ENROLMENT.ID) AS ENROLMENT_ID, " +
-            if (deviceType != null && !deviceType.isEmpty()) {
+                    "MIN(ENROLMENT.OWNER) AS OWNER, " +
-                sql += " AND DEVICE_TYPE.NAME=?";
+                    "MIN(ENROLMENT.OWNERSHIP) AS OWNERSHIP, " +
+                    "MIN(ENROLMENT.IS_TRANSFERRED) AS IS_TRANSFERRED, " +
+                    "MIN(ENROLMENT.DATE_OF_ENROLMENT) AS DATE_OF_ENROLMENT, " +
+                    "MIN(ENROLMENT.DATE_OF_LAST_UPDATE) AS DATE_OF_LAST_UPDATE, " +
+                    "MIN(ENROLMENT.STATUS) AS STATUS " +
+                    "FROM DM_DEVICE_LOCATION AS DEVICE_LOCATION, DM_DEVICE AS DEVICE, " +
+                    "DM_DEVICE_TYPE AS DEVICE_TYPE, DM_ENROLMENT AS ENROLMENT " +
+                    "WHERE DEVICE_LOCATION.LATITUDE BETWEEN ? AND ? " +
+                    "AND DEVICE_LOCATION.LONGITUDE BETWEEN ? AND ? ";
+            if (geoQuery.getDeviceTypes() != null && !geoQuery.getDeviceTypes().isEmpty()) {
+                sql += "AND DEVICE_TYPE.NAME IN (";
+                sql += String.join(", ",
+                        Collections.nCopies(geoQuery.getDeviceTypes().size(), "?"));
+                sql += ") ";
+            }
+            if (geoQuery.getDeviceIdentifiers() != null && !geoQuery.getDeviceIdentifiers().isEmpty()) {
+                sql += "AND DEVICE.DEVICE_IDENTIFICATION IN (";
+                sql += String.join(", ",
+                        Collections.nCopies(geoQuery.getDeviceIdentifiers().size(), "?"));
+                sql += ") ";
+            }
+            if (geoQuery.getOwners() != null && !geoQuery.getOwners().isEmpty()) {
+                sql += "AND ENROLMENT.OWNER IN (";
+                sql += String.join(", ",
+                        Collections.nCopies(geoQuery.getOwners().size(), "?"));
+                sql += ") ";
+            }
+            if (geoQuery.getOwnerships() != null && !geoQuery.getOwnerships().isEmpty()) {
+                sql += "AND ENROLMENT.OWNERSHIP IN (";
+                sql += String.join(", ",
+                        Collections.nCopies(geoQuery.getOwnerships().size(), "?"));
+                sql += ") ";
+            }
+            if (geoQuery.getStatuses() != null && !geoQuery.getStatuses().isEmpty()) {
+                sql += "AND ENROLMENT.STATUS IN (";
+                sql += String.join(", ",
+                        Collections.nCopies(geoQuery.getStatuses().size(), "?"));
+                sql += ") ";
+            } else {
+                sql += "AND ENROLMENT.STATUS != 'REMOVED' ";
+            }
+            if (geoQuery.getCreatedBefore() != 0 || geoQuery.getCreatedAfter() != 0) {
+                sql += "AND ENROLMENT.DATE_OF_ENROLMENT BETWEEN ? AND ? ";
             }
-            sql += " GROUP BY GEOHASH_PREFIX";
+            if (geoQuery.getUpdatedBefore() != 0 || geoQuery.getUpdatedAfter() != 0) {
+                sql += "AND ENROLMENT.DATE_OF_LAST_UPDATE BETWEEN ? AND ? ";
+            }
+            sql += "AND DEVICE.ID = DEVICE_LOCATION.DEVICE_ID AND DEVICE.DEVICE_TYPE_ID = DEVICE_TYPE.ID " +
+                    "AND DEVICE.ID = ENROLMENT.DEVICE_ID " +
+                    "AND DEVICE.TENANT_ID = ? AND DEVICE.TENANT_ID = ENROLMENT.TENANT_ID GROUP BY GEOHASH_PREFIX";
             stmt = conn.prepareStatement(sql);
-            stmt.setInt(1, geohashLength);
+
-            stmt.setDouble(2, southWest.getLatitude());
+            int index = 1;
-            stmt.setDouble(3, northEast.getLatitude());
+            stmt.setInt(index++, geoQuery.getGeohashLength());
-            stmt.setDouble(4, southWest.getLongitude());
+            stmt.setDouble(index++, geoQuery.getSouthWest().getLatitude());
-            stmt.setDouble(5, northEast.getLongitude());
+            stmt.setDouble(index++, geoQuery.getNorthEast().getLatitude());
-            stmt.setDouble(6, tenantId);
+            stmt.setDouble(index++, geoQuery.getSouthWest().getLongitude());
-            if (deviceType != null && !deviceType.isEmpty()) {
+            stmt.setDouble(index++, geoQuery.getNorthEast().getLongitude());
-                stmt.setString(7, deviceType);
+            if (geoQuery.getDeviceTypes() != null) {
+                for (String s: geoQuery.getDeviceTypes()) {
+                    stmt.setString(index++, s);
+                }
+            }
+            if (geoQuery.getDeviceIdentifiers() != null) {
+                for (String s: geoQuery.getDeviceIdentifiers()) {
+                    stmt.setString(index++, s);
+                }
+            }
+            if (geoQuery.getOwners() != null) {
+                for (String s: geoQuery.getOwners()) {
+                    stmt.setString(index++, s);
+                }
             }
+            if (geoQuery.getOwnerships() != null) {
+                for (String s: geoQuery.getOwnerships()) {
+                    stmt.setString(index++, s);
+                }
+            }
+            if (geoQuery.getStatuses() != null) {
+                for (Status s: geoQuery.getStatuses()) {
+                    stmt.setString(index++, s.toString());
+                }
+            }
+
+            if (geoQuery.getCreatedBefore() != 0 || geoQuery.getCreatedAfter() != 0) {
+                stmt.setTimestamp(index++, new Timestamp(geoQuery.getCreatedAfter()));
+                if (geoQuery.getCreatedBefore() == 0) {
+                    stmt.setTimestamp(index++, new Timestamp(System.currentTimeMillis()));
+                } else {
+                    stmt.setTimestamp(index++, new Timestamp(geoQuery.getCreatedBefore()));
+                }
+            }
+            if (geoQuery.getUpdatedBefore() != 0 || geoQuery.getUpdatedAfter() != 0) {
+                stmt.setTimestamp(index++, new Timestamp(geoQuery.getUpdatedAfter()));
+                if (geoQuery.getUpdatedBefore() == 0) {
+                    stmt.setTimestamp(index++, new Timestamp(System.currentTimeMillis()));
+                } else {
+                    stmt.setTimestamp(index++, new Timestamp(geoQuery.getUpdatedBefore()));
+                }
+            }
+            stmt.setInt(index, tenantId);
+
             rs = stmt.executeQuery();
+
+            double latitude;
+            double longitude;
+            double minLatitude;
+            double maxLatitude;
+            double minLongitude;
+            double maxLongitude;
+            long count;
+            String geohashPrefix;
+            Device device;
             while (rs.next()) {
-                double latitude = rs.getDouble("LATITUDE");
+                latitude = rs.getDouble("LATITUDE");
-                double longitude = rs.getDouble("LONGITUDE");
+                longitude = rs.getDouble("LONGITUDE");
-                double min_latitude = rs.getDouble("MIN_LATITUDE");
+                minLatitude = rs.getDouble("MIN_LATITUDE");
-                double max_latitude = rs.getDouble("MAX_LATITUDE");
+                maxLatitude = rs.getDouble("MAX_LATITUDE");
-                double min_longitude = rs.getDouble("MIN_LONGITUDE");
+                minLongitude = rs.getDouble("MIN_LONGITUDE");
-                double max_longitude = rs.getDouble("MAX_LONGITUDE");
+                maxLongitude = rs.getDouble("MAX_LONGITUDE");
-                String device_identification = rs.getString("DEVICE_IDENTIFICATION");
+                count = rs.getLong("COUNT");
-                String device_name = rs.getString("NAME");
+                geohashPrefix = rs.getString("GEOHASH_PREFIX");
-                String device_type = rs.getString("TYPE");
+                if (count == 1) {
-                String last_seen = rs.getString("LAST_UPDATED_TIMESTAMP");
+                    device = DeviceManagementDAOUtil.loadDevice(rs);
-                long count = rs.getLong("COUNT");
+                } else {
-                String geohashPrefix = rs.getString("GEOHASH_PREFIX");
+                    device = null;
+                }
                 geoClusters.add(new GeoCluster(new GeoCoordinate(latitude, longitude),
-                        new GeoCoordinate(min_latitude, min_longitude), new GeoCoordinate(max_latitude, max_longitude),
+                        new GeoCoordinate(minLatitude, minLongitude), new GeoCoordinate(maxLatitude, maxLongitude),
-                        count, geohashPrefix, device_identification, device_name, device_type, last_seen));
+                        count, geohashPrefix, device));
             }
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while retrieving information of  " +
+            throw new DeviceManagementDAOException("Error occurred while retrieving information of " +
                     "Geo Clusters", e);
         } finally {
             DeviceManagementDAOUtil.cleanupResources(stmt, rs);

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/dao/impl/device/SQLServerDeviceDAOImpl.java

@@ -18,7 +18,6 @@
 
 package org.wso2.carbon.device.mgt.core.dao.impl.device;
 
-import org.apache.commons.lang.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.wso2.carbon.device.mgt.common.Count;
@@ -29,8 +28,8 @@ import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOException;
 import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOFactory;
 import org.wso2.carbon.device.mgt.core.dao.impl.AbstractDeviceDAOImpl;
 import org.wso2.carbon.device.mgt.core.dao.util.DeviceManagementDAOUtil;
-import org.wso2.carbon.device.mgt.core.geo.GeoCluster;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCluster;
-import org.wso2.carbon.device.mgt.core.geo.geoHash.GeoCoordinate;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCoordinate;
 import org.wso2.carbon.device.mgt.core.report.mgt.Constants;
 
 import java.sql.Connection;
@@ -1133,6 +1132,8 @@ public class SQLServerDeviceDAOImpl extends AbstractDeviceDAOImpl {
         }
     }
 
+    //TODO: Override for MSSQL
+    /*
     @Override
     public List<GeoCluster> findGeoClusters(String deviceType, GeoCoordinate southWest, GeoCoordinate northEast,
                                             int geohashLength, int tenantId) throws DeviceManagementDAOException {
@@ -1207,4 +1208,5 @@ public class SQLServerDeviceDAOImpl extends AbstractDeviceDAOImpl {
         }
         return geoClusters;
     }
+     */
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/geo/GeoCluster.java

@@ -1,65 +0,0 @@
-package org.wso2.carbon.device.mgt.core.geo;
-
-import org.wso2.carbon.device.mgt.core.geo.geoHash.GeoCoordinate;
-
-public class GeoCluster {
-    private GeoCoordinate coordinates;
-    private GeoCoordinate southWestBound;
-    private GeoCoordinate northEastBound;
-    private long count;
-    private String geohashPrefix;
-    private String deviceIdentification;
-    private String deviceName;
-    private String deviceType;
-    private String lastSeen;
-
-
-    public GeoCluster(GeoCoordinate coordinates, GeoCoordinate southWestBound, GeoCoordinate northEastBound, long count,
-                      String geohashPrefix, String deviceIdentification, String deviceName, String deviceType, String lastSeen){
-        this.coordinates=coordinates;
-        this.southWestBound=southWestBound;
-        this.northEastBound=northEastBound;
-        this.count=count;
-        this.geohashPrefix=geohashPrefix;
-        this.deviceIdentification=deviceIdentification;
-        this.deviceName=deviceName;
-        this.deviceType=deviceType;
-        this.lastSeen = lastSeen;
-
-    }
-
-    public String getGeohashPrefix() {
-        return geohashPrefix;
-    }
-
-    public long getCount() {
-        return count;
-    }
-
-    public GeoCoordinate getCoordinates() {
-        return coordinates;
-    }
-
-    public GeoCoordinate getSouthWestBound() {
-        return southWestBound;
-    }
-
-    public GeoCoordinate getNorthEastBound() {
-        return northEastBound;
-    }
-
-    public String getDeviceIdentification() {
-        return deviceIdentification;
-    }
-
-    public String getDeviceName() {
-        return deviceName;
-    }
-
-    public String getDeviceType() { return deviceType;
-    }
-
-    public String getLastSeen() {
-        return lastSeen;
-    }
-}

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/geo/geoHash/GeoCoordinate.java

@@ -1,21 +0,0 @@
-package org.wso2.carbon.device.mgt.core.geo.geoHash;
-
-
-
-public class GeoCoordinate {
-    private double latitude;
-    private double longitude;
-
-    public GeoCoordinate(double latitude, double longitude){
-        this.latitude=latitude;
-        this.longitude=longitude;
-    }
-
-    public double getLatitude() {
-        return latitude;
-    }
-
-    public double getLongitude() {
-        return longitude;
-    }
-}

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/geo/geoHash/GeoHashGenerator.java

@@ -1,15 +1,33 @@
+/*
+ * Copyright (c) 2018-2021, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
+ *
+ * Entgra (Pvt) Ltd. 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.wso2.carbon.device.mgt.core.geo.geoHash;
 
 import org.wso2.carbon.device.mgt.common.device.details.DeviceLocation;
-
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCoordinate;
-import java.util.HashMap;
-import java.util.Map;
 
 public class GeoHashGenerator {
+
     private static final String BASE_32 = "0123456789bcdefghjkmnpqrstuvwxyz";
     private static final int GEOHASH_LENGTH = 16;
 
-    private GeoHashGenerator(){};
+    private GeoHashGenerator() {
+    }
 
     private static int divideRangeByValue(double value, double[] range) {
         double mid = middle(range);
@@ -36,7 +54,6 @@ public class GeoHashGenerator {
     }
 
     public static String encodeGeohash(double latitude, double longitude) {
-        int geohashLength=GEOHASH_LENGTH;
         double[] latRange = new double[]{-90.0, 90.0};
         double[] lonRange = new double[]{-180.0, 180.0};
         boolean isEven = true;
@@ -44,7 +61,7 @@ public class GeoHashGenerator {
         int base32CharIndex = 0;
         StringBuilder geohash = new StringBuilder();
 
-        while (geohash.length() < geohashLength) {
+        while (geohash.length() < GEOHASH_LENGTH) {
             if (isEven) {
                 base32CharIndex = (base32CharIndex << 1) | divideRangeByValue(longitude, lonRange);
             } else {
@@ -85,8 +102,7 @@ public class GeoHashGenerator {
                 isEvenBit = !isEvenBit;
             }
         }
-        GeoCoordinate coordinates = new GeoCoordinate(middle(latRange),middle(lonRange));
+        return new GeoCoordinate(middle(latRange), middle(lonRange));
-        return coordinates;
     }
 
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/geo/geoHash/geoHashStrategy/GeoHashLengthStrategy.java

@@ -1,11 +1,31 @@
+/*
+ * Copyright (c) 2018-2021, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
+ *
+ * Entgra (Pvt) Ltd. 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.wso2.carbon.device.mgt.core.geo.geoHash.geoHashStrategy;
 
-import org.wso2.carbon.device.mgt.core.geo.geoHash.GeoCoordinate;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCoordinate;
 
 /**
  * This interface is to decide a length for the geohash prefix
  * which will be used to group the clusters based on geohash
  */
 public interface GeoHashLengthStrategy {
+
     int getGeohashLength(GeoCoordinate southWest, GeoCoordinate northEast, int zoom);
+
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/geo/geoHash/geoHashStrategy/ZoomGeoHashLengthStrategy.java

@@ -1,11 +1,31 @@
+/*
+ * Copyright (c) 2018-2021, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
+ *
+ * Entgra (Pvt) Ltd. 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.wso2.carbon.device.mgt.core.geo.geoHash.geoHashStrategy;
 
-import org.wso2.carbon.device.mgt.core.geo.geoHash.GeoCoordinate;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCoordinate;
 
-/**A class that will decide the geoHashLength based on the zoom level and
+/**
-* the boundaries of the map**/
+ * A class that will decide the geoHashLength based on the zoom level and
+ * the boundaries of the map
+ **/
 
-public class ZoomGeoHashLengthStrategy implements GeoHashLengthStrategy{
+public class ZoomGeoHashLengthStrategy implements GeoHashLengthStrategy {
 
     private int minGeohashLength = 1;
     private int maxGeohashLength = 16;
@@ -19,35 +39,36 @@ public class ZoomGeoHashLengthStrategy implements GeoHashLengthStrategy{
         return (int) Math.max(minGeohashLength, Math.min(a * Math.exp(b * zoom), maxGeohashLength));
     }
 
+    public int getMinGeohashLength() {
+        return minGeohashLength;
+    }
+
     public void setMinGeohashLength(int minGeohashLength) {
         this.minGeohashLength = minGeohashLength;
     }
 
-    public void setMaxGeohashLength(int maxGeohashLength) {
+    public int getMaxGeohashLength() {
-        this.maxGeohashLength = maxGeohashLength;
+        return maxGeohashLength;
     }
 
-    public void setMinZoom(int minZoom) {
+    public void setMaxGeohashLength(int maxGeohashLength) {
-        this.minZoom = minZoom;
+        this.maxGeohashLength = maxGeohashLength;
     }
 
-    public void setMaxZoom(int maxZoom) {
+    public int getMinZoom() {
-        this.maxZoom = maxZoom;
+        return minZoom;
     }
 
-    public int getMinGeohashLength() {
+    public void setMinZoom(int minZoom) {
-        return minGeohashLength;
+        this.minZoom = minZoom;
     }
 
-    public int getMaxGeohashLength() {
+    public int getMaxZoom() {
-        return maxGeohashLength;
+        return maxZoom;
     }
 
-    public int getMinZoom() {
+    public void setMaxZoom(int maxZoom) {
-        return minZoom;
+        this.maxZoom = maxZoom;
     }
 
-    public int getMaxZoom() {
-        return maxZoom;
-    }
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/geo/service/GeoLocationProviderServiceImpl.java

@@ -44,11 +44,11 @@ import org.wso2.carbon.device.mgt.common.event.config.EventConfigurationExceptio
 import org.wso2.carbon.device.mgt.common.event.config.EventConfigurationProviderService;
 import org.wso2.carbon.device.mgt.common.exceptions.TransactionManagementException;
 import org.wso2.carbon.device.mgt.common.geo.service.Alert;
+import org.wso2.carbon.device.mgt.common.geo.service.AlertAlreadyExistException;
 import org.wso2.carbon.device.mgt.common.geo.service.GeoFence;
 import org.wso2.carbon.device.mgt.common.geo.service.GeoFenceEventMeta;
-import org.wso2.carbon.device.mgt.common.geo.service.GeoLocationProviderService;
 import org.wso2.carbon.device.mgt.common.geo.service.GeoLocationBasedServiceException;
-import org.wso2.carbon.device.mgt.common.geo.service.AlertAlreadyExistException;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoLocationProviderService;
 import org.wso2.carbon.device.mgt.common.geo.service.GeofenceData;
 import org.wso2.carbon.device.mgt.core.cache.impl.GeoCacheManagerImpl;
 import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOException;
@@ -85,11 +85,11 @@ import java.security.UnrecoverableKeyException;
 import java.security.cert.CertificateException;
 import java.sql.SQLException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
-import java.util.Collections;
 import java.util.Set;
 
 import static org.wso2.carbon.device.mgt.common.DeviceManagementConstants.GeoServices.DAS_PORT;
@@ -101,7 +101,7 @@ import static org.wso2.carbon.device.mgt.common.DeviceManagementConstants.GeoSer
  */
 public class GeoLocationProviderServiceImpl implements GeoLocationProviderService {
 
-    private static Log log = LogFactory.getLog(GeoLocationProviderServiceImpl.class);
+    private static final Log log = LogFactory.getLog(GeoLocationProviderServiceImpl.class);
 
     /**
      * required soap header for authorization
@@ -136,6 +136,18 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
         this.geofenceDAO = DeviceManagementDAOFactory.getGeofenceDAO();
     }
 
+    public static JWTClientManagerService getJWTClientManagerService() {
+        JWTClientManagerService jwtClientManagerService;
+        PrivilegedCarbonContext ctx = PrivilegedCarbonContext.getThreadLocalCarbonContext();
+        jwtClientManagerService = (JWTClientManagerService) ctx.getOSGiService(JWTClientManagerService.class, null);
+        if (jwtClientManagerService == null) {
+            String msg = "jwtClientManagerServicehas not initialized.";
+            log.error(msg);
+            throw new IllegalStateException(msg);
+        }
+        return jwtClientManagerService;
+    }
+
     @Override
     public List<GeoFence> getWithinAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException {
 
@@ -227,7 +239,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
             return fences;
         } catch (RegistryException | IOException e) {
             throw new GeoLocationBasedServiceException(
-                    "Error occurred while getting the geo alerts" , e);
+                    "Error occurred while getting the geo alerts", e);
         }
     }
 
@@ -334,7 +346,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
 
     @Override
     public boolean createGeoAlert(Alert alert, String alertType)
-            throws GeoLocationBasedServiceException,AlertAlreadyExistException {
+            throws GeoLocationBasedServiceException, AlertAlreadyExistException {
         return saveGeoAlert(alert, alertType, false);
     }
 
@@ -346,12 +358,12 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
 
     @Override
     public boolean updateGeoAlert(Alert alert, String alertType)
-            throws GeoLocationBasedServiceException,AlertAlreadyExistException {
+            throws GeoLocationBasedServiceException, AlertAlreadyExistException {
         return saveGeoAlert(alert, alertType, true);
     }
 
     private boolean saveGeoAlert(Alert alert, String alertType, boolean isUpdate)
-            throws GeoLocationBasedServiceException,AlertAlreadyExistException {
+            throws GeoLocationBasedServiceException, AlertAlreadyExistException {
 
         Type type = new TypeToken<Map<String, String>>() {
         }.getType();
@@ -408,7 +420,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
             if (validationResponse.equals("success")) {
                 allActiveExecutionPlanConfigs = eventprocessorStub.getAllActiveExecutionPlanConfigurations();
                 if (isUpdate) {
-                    for (ExecutionPlanConfigurationDto activeExectionPlanConfig:allActiveExecutionPlanConfigs) {
+                    for (ExecutionPlanConfigurationDto activeExectionPlanConfig : allActiveExecutionPlanConfigs) {
                         activeExecutionPlan = activeExectionPlanConfig.getExecutionPlan();
                         if (activeExecutionPlan.contains(executionPlanName)) {
                             eventprocessorStub.editActiveExecutionPlan(parsedTemplate, executionPlanName);
@@ -417,14 +429,14 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
                     }
                     eventprocessorStub.deployExecutionPlan(parsedTemplate);
                 } else {
-                    for (ExecutionPlanConfigurationDto activeExectionPlanConfig:allActiveExecutionPlanConfigs) {
+                    for (ExecutionPlanConfigurationDto activeExectionPlanConfig : allActiveExecutionPlanConfigs) {
                         activeExecutionPlan = activeExectionPlanConfig.getExecutionPlan();
                         if (activeExecutionPlan.contains(executionPlanName)) {
                             throw new AlertAlreadyExistException("Execution plan already exists with name "
                                     + executionPlanName);
                         }
                     }
-                    updateRegistry(getRegistryPath(alertType, alert.getQueryName()),content,options);
+                    updateRegistry(getRegistryPath(alertType, alert.getQueryName()), content, options);
                     eventprocessorStub.deployExecutionPlan(parsedTemplate);
                 }
             } else {
@@ -519,7 +531,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
             if (validationResponse.equals("success")) {
                 allActiveExecutionPlanConfigs = eventprocessorStub.getAllActiveExecutionPlanConfigurations();
                 if (isUpdate) {
-                    for (ExecutionPlanConfigurationDto activeExectionPlanConfig:allActiveExecutionPlanConfigs) {
+                    for (ExecutionPlanConfigurationDto activeExectionPlanConfig : allActiveExecutionPlanConfigs) {
                         activeExecutionPlan = activeExectionPlanConfig.getExecutionPlan();
                         if (activeExecutionPlan.contains(executionPlanName)) {
                             eventprocessorStub.editActiveExecutionPlan(parsedTemplate, executionPlanName);
@@ -528,7 +540,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
                     }
                     eventprocessorStub.deployExecutionPlan(parsedTemplate);
                 } else {
-                    for (ExecutionPlanConfigurationDto activeExectionPlanConfig:allActiveExecutionPlanConfigs) {
+                    for (ExecutionPlanConfigurationDto activeExectionPlanConfig : allActiveExecutionPlanConfigs) {
                         activeExecutionPlan = activeExectionPlanConfig.getExecutionPlan();
                         if (activeExecutionPlan.contains(executionPlanName)) {
                             throw new AlertAlreadyExistException("Execution plan already exists with name "
@@ -605,32 +617,32 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
     }
 
     private String getRegistryPath(String alertType, String queryName)
-                throws GeoLocationBasedServiceException {
+            throws GeoLocationBasedServiceException {
-            String path = "";
+        String path = "";
-            if (GeoServices.ALERT_TYPE_WITHIN.equals(alertType)) {
+        if (GeoServices.ALERT_TYPE_WITHIN.equals(alertType)) {
-                path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_WITHIN +
+            path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_WITHIN +
-                        "/" + "/" + queryName;
+                    "/" + "/" + queryName;
-            } else if (GeoServices.ALERT_TYPE_EXIT.equals(alertType)) {
+        } else if (GeoServices.ALERT_TYPE_EXIT.equals(alertType)) {
-                path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_EXIT +
+            path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_EXIT +
-                        "/" + queryName;
+                    "/" + queryName;
-            } else if (GeoServices.ALERT_TYPE_SPEED.equals(alertType)) {
+        } else if (GeoServices.ALERT_TYPE_SPEED.equals(alertType)) {
-                path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_SPEED +
+            path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_SPEED +
-                        "/" ;
+                    "/";
-            } else if (GeoServices.ALERT_TYPE_PROXIMITY.equals(alertType)) {
+        } else if (GeoServices.ALERT_TYPE_PROXIMITY.equals(alertType)) {
-                path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_PROXIMITY +
+            path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_PROXIMITY +
-                        "/" + queryName;
+                    "/" + queryName;
-            } else if (GeoServices.ALERT_TYPE_STATIONARY.equals(alertType)) {
+        } else if (GeoServices.ALERT_TYPE_STATIONARY.equals(alertType)) {
-                path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_STATIONARY +
+            path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_STATIONARY +
-                        "/" + queryName;
+                    "/" + queryName;
-            } else if (GeoServices.ALERT_TYPE_TRAFFIC.equals(alertType)) {
+        } else if (GeoServices.ALERT_TYPE_TRAFFIC.equals(alertType)) {
-                path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_TRAFFIC +
+            path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_TRAFFIC +
-                        "/" + queryName;
+                    "/" + queryName;
-            } else {
+        } else {
-                throw new GeoLocationBasedServiceException(
+            throw new GeoLocationBasedServiceException(
-                        "Unrecognized execution plan type: " + alertType);
+                    "Unrecognized execution plan type: " + alertType);
-            }
-            return path;
         }
+        return path;
+    }
 
     private String getExecutionPlanName(String alertType, String queryName, String deviceId, String owner) {
         if (GeoServices.ALERT_TYPE_TRAFFIC.equals(alertType)) {
@@ -798,7 +810,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
             InputStream inputStream = resource.getContentStream();
             StringWriter writer = new StringWriter();
             IOUtils.copy(inputStream, writer, "UTF-8");
-            return "{'speedLimit':" + writer.toString() + "}";
+            return "{'speedLimit':" + writer + "}";
         } catch (RegistryException | IOException e) {
             return "{'content': false}";
         }
@@ -816,7 +828,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
             InputStream inputStream = resource.getContentStream();
             StringWriter writer = new StringWriter();
             IOUtils.copy(inputStream, writer, "UTF-8");
-            return "{'speedLimit':" + writer.toString() + "}";
+            return "{'speedLimit':" + writer + "}";
         } catch (RegistryException | IOException e) {
             return "{'content': false}";
         }
@@ -835,8 +847,8 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
                 List proxTimeObj = (List) props.get(GeoServices.PROXIMITY_TIME);
 
                 return String.format("{proximityDistance:\"%s\", proximityTime:\"%s\"}",
-                                     proxDisObj != null ? proxDisObj.get(0).toString() : "",
+                        proxDisObj != null ? proxDisObj.get(0).toString() : "",
-                                     proxTimeObj != null ? proxTimeObj.get(0).toString() : "");
+                        proxTimeObj != null ? proxTimeObj.get(0).toString() : "");
             } else {
                 return "{'content': false}";
             }
@@ -868,7 +880,6 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
         }
     }
 
-
     @Override
     public List<GeoFence> getStationaryAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException {
 
@@ -1079,7 +1090,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
     }
 
     private String parseTemplate(String alertType, Map<String, String> parseMap) throws
-                                                                                 GeoLocationBasedServiceException {
+            GeoLocationBasedServiceException {
         String templatePath = "alerts/Geo-ExecutionPlan-" + alertType + "_alert.siddhiql";
         InputStream resource = getClass().getClassLoader().getResourceAsStream(templatePath);
         if (resource == null) {
@@ -1142,22 +1153,22 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
     }
 
     private void updateRegistry(String path, Object content, Map<String, String> options)
-                throws GeoLocationBasedServiceException {
+            throws GeoLocationBasedServiceException {
-            try {
+        try {
 
-                Registry registry = getGovernanceRegistry();
+            Registry registry = getGovernanceRegistry();
-                Resource newResource = registry.newResource();
+            Resource newResource = registry.newResource();
-                newResource.setContent(content);
+            newResource.setContent(content);
-                newResource.setMediaType("application/json");
+            newResource.setMediaType("application/json");
-                for (Map.Entry<String, String> option : options.entrySet()) {
+            for (Map.Entry<String, String> option : options.entrySet()) {
-                    newResource.addProperty(option.getKey(), option.getValue());
+                newResource.addProperty(option.getKey(), option.getValue());
-                }
-                registry.put(path, newResource);
-            } catch (RegistryException e) {
-                throw new GeoLocationBasedServiceException(
-                        "Error occurred while setting the Within Alert", e);
             }
+            registry.put(path, newResource);
+        } catch (RegistryException e) {
+            throw new GeoLocationBasedServiceException(
+                    "Error occurred while setting the Within Alert", e);
         }
+    }
 
     /**
      * Loads the keystore.
@@ -1207,7 +1218,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
      */
     private SSLContext initSSLConnection(String tenantAdminUser)
             throws NoSuchAlgorithmException, UnrecoverableKeyException,
-                   KeyStoreException, KeyManagementException, IOException, CertificateException {
+            KeyStoreException, KeyManagementException, IOException, CertificateException {
         String keyStorePassword = ServerConfiguration.getInstance().getFirstProperty("Security.KeyStore.Password");
         String trustStorePassword = ServerConfiguration.getInstance().getFirstProperty(
                 "Security.TrustStore.Password");
@@ -1243,18 +1254,6 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
         }
     }
 
-    public static JWTClientManagerService getJWTClientManagerService() {
-        JWTClientManagerService jwtClientManagerService;
-        PrivilegedCarbonContext ctx = PrivilegedCarbonContext.getThreadLocalCarbonContext();
-        jwtClientManagerService = (JWTClientManagerService) ctx.getOSGiService(JWTClientManagerService.class, null);
-        if (jwtClientManagerService == null) {
-            String msg = "jwtClientManagerServicehas not initialized.";
-            log.error(msg);
-            throw new IllegalStateException(msg);
-        }
-        return jwtClientManagerService;
-    }
-
     @Override
     public boolean createGeofence(GeofenceData geofenceData) throws GeoLocationBasedServiceException, EventConfigurationException {
         int tenantId;
@@ -1291,7 +1290,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
         List<Integer> createdEventIds;
         try {
             setEventSource(geofenceData.getEventConfig());
-            eventConfigService =  DeviceManagementDataHolder.getInstance().getEventConfigurationService();
+            eventConfigService = DeviceManagementDataHolder.getInstance().getEventConfigurationService();
             createdEventIds = eventConfigService.createEventsOfDeviceGroup(geofenceData.getEventConfig(), geofenceData.getGroupIds());
             DeviceManagementDAOFactory.beginTransaction();
             geofenceDAO.createGeofenceEventMapping(geofenceData.getId(), createdEventIds);
@@ -1333,6 +1332,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
 
     /**
      * Set source of the event to GEOFENCE
+     *
      * @param eventConfig event list to be set event source
      */
     private void setEventSource(List<EventConfig> eventConfig) {
@@ -1365,7 +1365,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
             }
             return geofence;
         } catch (DeviceManagementDAOException e) {
-            String msg = "Error occurred while retrieving Geofence data with ID "+fenceId;
+            String msg = "Error occurred while retrieving Geofence data with ID " + fenceId;
             log.error(msg, e);
             throw new GeoLocationBasedServiceException(msg, e);
         } catch (SQLException e) {
@@ -1608,7 +1608,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
         try {
             tenantId = DeviceManagementDAOUtil.getTenantId();
             setEventSource(geofenceData.getEventConfig());
-            eventConfigService =  DeviceManagementDataHolder.getInstance().getEventConfigurationService();
+            eventConfigService = DeviceManagementDataHolder.getInstance().getEventConfigurationService();
             if (eventConfigService == null) {
                 String msg = "Failed to load EventConfigurationProviderService osgi service of tenant " + tenantId;
                 log.error(msg);
@@ -1747,8 +1747,9 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
 
     /**
      * Delete events of geofence
+     *
      * @param geofenceData geofence mapped with deleting events
-     * @param eventList events to be deleted
+     * @param eventList    events to be deleted
      */
     private void deleteGeoFenceEvents(GeofenceData geofenceData, List<EventConfig> eventList)
             throws GeoLocationBasedServiceException {
@@ -1762,7 +1763,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
         }
 
         try {
-            EventConfigurationProviderService eventConfigService =  DeviceManagementDataHolder
+            EventConfigurationProviderService eventConfigService = DeviceManagementDataHolder
                     .getInstance().getEventConfigurationService();
             eventConfigService.deleteEvents(eventList);
             eventConfigService.createEventOperationTask(OperationMgtConstants.OperationCodes.EVENT_REVOKE,

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/geo/task/EventCreateCallback.java

@@ -17,6 +17,7 @@
  */
 
 package org.wso2.carbon.device.mgt.core.geo.task;
+
 public interface EventCreateCallback {
     void onCompleteEventOperation(Object values);
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/geo/task/EventOperationTaskException.java

@@ -18,7 +18,8 @@
 
 package org.wso2.carbon.device.mgt.core.geo.task;
 
-public class EventOperationTaskException extends Exception{
+public class EventOperationTaskException extends Exception {
+
     public EventOperationTaskException(String message) {
         super(message);
     }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/geo/task/GeoFenceEventOperationManager.java

@@ -45,14 +45,15 @@ public class GeoFenceEventOperationManager {
         this.eventOperationCode = eventOperationCode;
         this.tenantId = tenantId;
         this.callback = callback;
-        isEventEnabled= DeviceConfigurationManager.getInstance().getDeviceManagementConfig()
+        isEventEnabled = DeviceConfigurationManager.getInstance().getDeviceManagementConfig()
                 .getEventOperationTaskConfiguration().isEnabled();
     }
 
     /**
      * Get executor for create EVENT_CONFIG / EVENT_REVOKE operations at the time of a device/s
      * assigned into a group or removed from a group
-     * @param groupId Id of the assigned / removed group
+     *
+     * @param groupId           Id of the assigned / removed group
      * @param deviceIdentifiers Device identifiers assigned to / removed from the group
      * @return {@link GroupAssignmentEventOperationExecutor} Created executor to create operations
      */
@@ -72,7 +73,8 @@ public class GeoFenceEventOperationManager {
 
     /**
      * Get executor for create EVENT_CONFIG / EVENT_REVOKE operations at the time of a event is created
-     * @param groupIds list of group ids to apply the created event
+     *
+     * @param groupIds      list of group ids to apply the created event
      * @param eventMetaData contains all the data of the related event
      * @return {@link EventOperationExecutor} The created event executor object
      */

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/service/DeviceManagementProviderService.java

@@ -62,6 +62,7 @@ import org.wso2.carbon.device.mgt.common.exceptions.DeviceTypeNotFoundException;
 import org.wso2.carbon.device.mgt.common.exceptions.InvalidDeviceException;
 import org.wso2.carbon.device.mgt.common.exceptions.UnauthorizedDeviceAccessException;
 import org.wso2.carbon.device.mgt.common.exceptions.UserNotFoundException;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoQuery;
 import org.wso2.carbon.device.mgt.common.invitation.mgt.DeviceEnrollmentInvitationDetails;
 import org.wso2.carbon.device.mgt.common.license.mgt.License;
 import org.wso2.carbon.device.mgt.common.operation.mgt.Activity;
@@ -74,8 +75,8 @@ import org.wso2.carbon.device.mgt.common.spi.DeviceManagementService;
 import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOException;
 import org.wso2.carbon.device.mgt.core.dto.DeviceType;
 import org.wso2.carbon.device.mgt.core.dto.DeviceTypeVersion;
-import org.wso2.carbon.device.mgt.core.geo.GeoCluster;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCluster;
-import org.wso2.carbon.device.mgt.core.geo.geoHash.GeoCoordinate;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCoordinate;
 
 import java.sql.SQLException;
 import java.util.Date;
@@ -827,8 +828,7 @@ public interface DeviceManagementProviderService {
 
     List<Integer> getDeviceEnrolledTenants() throws DeviceManagementException;
 
-    List<GeoCluster> findGeoClusters(String deviceType, GeoCoordinate southWest, GeoCoordinate northEast,
+    List<GeoCluster> findGeoClusters(GeoQuery geoQuery) throws DeviceManagementException;
-                                     int geohashLength) throws DeviceManagementException;
 
     int getDeviceCountOfTypeByStatus(String deviceType, String deviceStatus) throws DeviceManagementException;
 

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/service/DeviceManagementProviderServiceImpl.java

@@ -92,6 +92,7 @@ import org.wso2.carbon.device.mgt.common.exceptions.InvalidDeviceException;
 import org.wso2.carbon.device.mgt.common.exceptions.TransactionManagementException;
 import org.wso2.carbon.device.mgt.common.exceptions.UnauthorizedDeviceAccessException;
 import org.wso2.carbon.device.mgt.common.exceptions.UserNotFoundException;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoQuery;
 import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroup;
 import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroupConstants;
 import org.wso2.carbon.device.mgt.common.group.mgt.GroupAlreadyExistException;
@@ -128,8 +129,8 @@ import org.wso2.carbon.device.mgt.core.device.details.mgt.DeviceInformationManag
 import org.wso2.carbon.device.mgt.core.dto.DeviceType;
 import org.wso2.carbon.device.mgt.core.dto.DeviceTypeServiceIdentifier;
 import org.wso2.carbon.device.mgt.core.dto.DeviceTypeVersion;
-import org.wso2.carbon.device.mgt.core.geo.GeoCluster;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCluster;
-import org.wso2.carbon.device.mgt.core.geo.geoHash.GeoCoordinate;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoCoordinate;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
 import org.wso2.carbon.device.mgt.core.internal.PluginInitializationListener;
@@ -3371,18 +3372,13 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
     }
 
     @Override
-    public List<GeoCluster> findGeoClusters(String deviceType, GeoCoordinate southWest, GeoCoordinate northEast,
+    public List<GeoCluster> findGeoClusters(GeoQuery geoQuery) throws DeviceManagementException {
-                                            int geohashLength) throws DeviceManagementException {
         if (log.isDebugEnabled()) {
-            if (deviceType == null || deviceType.isEmpty()) {
+            log.debug("Get information about geo clusters for query: " + new Gson().toJson(geoQuery));
-                log.debug("get information about geo clusters.");
-            } else {
-                log.debug("get information about geo clusters for device type: " + deviceType);
-            }
         }
         try {
             DeviceManagementDAOFactory.openConnection();
-            return deviceDAO.findGeoClusters(deviceType, southWest, northEast, geohashLength, this.getTenantId());
+            return deviceDAO.findGeoClusters(geoQuery, this.getTenantId());
         } catch (DeviceManagementDAOException e) {
             String msg = "Error occurred while retrieving the geo clusters.";
             log.error(msg, e);