community/device-mgt-core
1
0
Fork 0
mirror of https://repository.entgra.net/community/device-mgt-core.git synced 2025-10-06 02:01:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'geo-view' into 'master'

Browse Source 
Add geo view API

See merge request entgra/carbon-device-mgt!775
This commit is contained in:
Charitha Goonetilleke 2021-06-06 04:12:09 +00:00
commit 89ae048a5d
21 changed files with 875 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
components/device-mgt/org.wso2.carbon.device.mgt.api/src/main/java/org/wso2/carbon/device/mgt/jaxrs/beans/GeoCluster.java Normal file
View File

@ -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;
}
}

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

@ -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

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

@ -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}")

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

@ -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.core.geo.geoHash.GeoCoordinate;
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.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(),

66
components/device-mgt/org.wso2.carbon.device.mgt.common/src/main/java/org/wso2/carbon/device/mgt/common/geo/service/GeoCluster.java Normal file
View File

@ -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;
}
}

39
components/device-mgt/org.wso2.carbon.device.mgt.common/src/main/java/org/wso2/carbon/device/mgt/common/geo/service/GeoCoordinate.java Normal file
View File

@ -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;
}
}

139
components/device-mgt/org.wso2.carbon.device.mgt.common/src/main/java/org/wso2/carbon/device/mgt/common/geo/service/GeoQuery.java Normal file
View File

@ -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;
}
}

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

@ -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.core.geo.geoHash.GeoCoordinate;
import org.wso2.carbon.device.mgt.common.geo.service.GeoCluster;
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 southWest the coordinates of southWest corner of the map.
* @param northEast the coordinates of northEast corner of the map.
* @param tenantId tenant id.
* @param geoQuery the query to determine the geo data.
* @param tenantId tenant id.
* @return returns a list of enrolment info objects.
*/
List<GeoCluster> findGeoClusters(String deviceType, GeoCoordinate southWest, GeoCoordinate northEast,
int geohashLength,int tenantId) throws DeviceManagementDAOException;
List<GeoCluster> findGeoClusters(GeoQuery geoQuery, int tenantId) throws DeviceManagementDAOException;
/**
* This method is used to identify whether given device ids are exist or not.

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

@ -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.core.geo.geoHash.GeoCoordinate;
import org.wso2.carbon.device.mgt.common.geo.service.GeoCluster;
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,
int geohashLength, int tenantId) throws DeviceManagementDAOException {
public List<GeoCluster> findGeoClusters(GeoQuery geoQuery, 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," +
" MIN(DEVICE_LOCATION.LATITUDE) AS MIN_LATITUDE, MAX(DEVICE_LOCATION.LATITUDE) AS MAX_LATITUDE," +
" MIN(DEVICE_LOCATION.LONGITUDE) AS MIN_LONGITUDE," +
" MAX(DEVICE_LOCATION.LONGITUDE) AS MAX_LONGITUDE," +
" SUBSTRING(DEVICE_LOCATION.GEO_HASH,1,?) AS GEOHASH_PREFIX, COUNT(*) AS COUNT," +
" MIN(DEVICE.DEVICE_IDENTIFICATION) AS DEVICE_IDENTIFICATION," +
" MIN(DEVICE.NAME) AS NAME," +
" MIN(DEVICE_TYPE.NAME) AS TYPE, " +
" MIN(DEVICE.LAST_UPDATED_TIMESTAMP) AS LAST_UPDATED_TIMESTAMP " +
"FROM DM_DEVICE_LOCATION AS DEVICE_LOCATION,DM_DEVICE AS DEVICE, DM_DEVICE_TYPE AS DEVICE_TYPE " +
"WHERE DEVICE_LOCATION.LATITUDE BETWEEN ? AND ? AND " +
"DEVICE_LOCATION.LONGITUDE BETWEEN ? AND ? AND " +
"DEVICE.TENANT_ID=? AND " +
"DEVICE.ID=DEVICE_LOCATION.DEVICE_ID AND DEVICE.DEVICE_TYPE_ID=DEVICE_TYPE.ID";
if (deviceType != null && !deviceType.isEmpty()) {
sql += " AND DEVICE_TYPE.NAME=?";
String sql = "SELECT AVG(DEVICE_LOCATION.LATITUDE) AS LATITUDE, " +
"AVG(DEVICE_LOCATION.LONGITUDE) AS LONGITUDE, " +
"MIN(DEVICE_LOCATION.LATITUDE) AS MIN_LATITUDE, " +
"MAX(DEVICE_LOCATION.LATITUDE) AS MAX_LATITUDE, " +
"MIN(DEVICE_LOCATION.LONGITUDE) AS MIN_LONGITUDE, " +
"MAX(DEVICE_LOCATION.LONGITUDE) AS MAX_LONGITUDE, " +
"SUBSTRING(DEVICE_LOCATION.GEO_HASH,1,?) AS GEOHASH_PREFIX, " +
"COUNT(DEVICE_LOCATION.ID) AS COUNT, " +
"MIN(DEVICE.ID) AS DEVICE_ID, " +
"MIN(DEVICE.NAME) AS DEVICE_NAME, " +
"MIN(DEVICE.DESCRIPTION) AS DESCRIPTION, " +
"MIN(DEVICE_TYPE.NAME) AS DEVICE_TYPE, " +
"MIN(DEVICE.DEVICE_IDENTIFICATION) AS DEVICE_IDENTIFICATION, " +
"MIN(ENROLMENT.ID) AS ENROLMENT_ID, " +
"MIN(ENROLMENT.OWNER) AS OWNER, " +
"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 += ") ";
}
sql += " GROUP BY GEOHASH_PREFIX";
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 ? ";
}
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());
stmt.setDouble(3, northEast.getLatitude());
stmt.setDouble(4, southWest.getLongitude());
stmt.setDouble(5, northEast.getLongitude());
stmt.setDouble(6, tenantId);
if (deviceType != null && !deviceType.isEmpty()) {
stmt.setString(7, deviceType);
int index = 1;
stmt.setInt(index++, geoQuery.getGeohashLength());
stmt.setDouble(index++, geoQuery.getSouthWest().getLatitude());
stmt.setDouble(index++, geoQuery.getNorthEast().getLatitude());
stmt.setDouble(index++, geoQuery.getSouthWest().getLongitude());
stmt.setDouble(index++, geoQuery.getNorthEast().getLongitude());
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");
double longitude = rs.getDouble("LONGITUDE");
double min_latitude = rs.getDouble("MIN_LATITUDE");
double max_latitude = rs.getDouble("MAX_LATITUDE");
double min_longitude = rs.getDouble("MIN_LONGITUDE");
double max_longitude = rs.getDouble("MAX_LONGITUDE");
String device_identification = rs.getString("DEVICE_IDENTIFICATION");
String device_name = rs.getString("NAME");
String device_type = rs.getString("TYPE");
String last_seen = rs.getString("LAST_UPDATED_TIMESTAMP");
long count = rs.getLong("COUNT");
String geohashPrefix = rs.getString("GEOHASH_PREFIX");
latitude = rs.getDouble("LATITUDE");
longitude = rs.getDouble("LONGITUDE");
minLatitude = rs.getDouble("MIN_LATITUDE");
maxLatitude = rs.getDouble("MAX_LATITUDE");
minLongitude = rs.getDouble("MIN_LONGITUDE");
maxLongitude = rs.getDouble("MAX_LONGITUDE");
count = rs.getLong("COUNT");
geohashPrefix = rs.getString("GEOHASH_PREFIX");
if (count == 1) {
device = DeviceManagementDAOUtil.loadDevice(rs);
} else {
device = null;
}
geoClusters.add(new GeoCluster(new GeoCoordinate(latitude, longitude),
new GeoCoordinate(min_latitude, min_longitude), new GeoCoordinate(max_latitude, max_longitude),
count, geohashPrefix, device_identification, device_name, device_type, last_seen));
new GeoCoordinate(minLatitude, minLongitude), new GeoCoordinate(maxLatitude, maxLongitude),
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);

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

@ -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.core.geo.geoHash.GeoCoordinate;
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.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;
}
*/
}

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

@ -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;
}
}

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

@ -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;
}
}

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

@ -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 java.util.HashMap;
import java.util.Map;
import org.wso2.carbon.device.mgt.common.geo.service.GeoCoordinate;
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 coordinates;
return new GeoCoordinate(middle(latRange), middle(lonRange));
}
}

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

@ -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);
}

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

@ -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 void setMinGeohashLength(int minGeohashLength) {
this.minGeohashLength = minGeohashLength;
}
public void setMaxGeohashLength(int maxGeohashLength) {
this.maxGeohashLength = maxGeohashLength;
}
public void setMinZoom(int minZoom) {
this.minZoom = minZoom;
}
public void setMaxZoom(int maxZoom) {
this.maxZoom = maxZoom;
}
public int getMinGeohashLength() {
return minGeohashLength;
}
public void setMinGeohashLength(int minGeohashLength) {
this.minGeohashLength = minGeohashLength;
}
public int getMaxGeohashLength() {
return maxGeohashLength;
}
public void setMaxGeohashLength(int maxGeohashLength) {
this.maxGeohashLength = maxGeohashLength;
}
public int getMinZoom() {
return minZoom;
}
public void setMinZoom(int minZoom) {
this.minZoom = minZoom;
}
public int getMaxZoom() {
return maxZoom;
}
public void setMaxZoom(int maxZoom) {
this.maxZoom = maxZoom;
}
}

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

@ -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 {
String path = "";
if (GeoServices.ALERT_TYPE_WITHIN.equals(alertType)) {
path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_WITHIN +
"/" + "/" + queryName;
} else if (GeoServices.ALERT_TYPE_EXIT.equals(alertType)) {
path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_EXIT +
"/" + queryName;
} else if (GeoServices.ALERT_TYPE_SPEED.equals(alertType)) {
path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_SPEED +
"/" ;
} else if (GeoServices.ALERT_TYPE_PROXIMITY.equals(alertType)) {
path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_PROXIMITY +
"/" + queryName;
} else if (GeoServices.ALERT_TYPE_STATIONARY.equals(alertType)) {
path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_STATIONARY +
"/" + queryName;
} else if (GeoServices.ALERT_TYPE_TRAFFIC.equals(alertType)) {
path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_TRAFFIC +
"/" + queryName;
} else {
throw new GeoLocationBasedServiceException(
"Unrecognized execution plan type: " + alertType);
}
return path;
throws GeoLocationBasedServiceException {
String path = "";
if (GeoServices.ALERT_TYPE_WITHIN.equals(alertType)) {
path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_WITHIN +
"/" + "/" + queryName;
} else if (GeoServices.ALERT_TYPE_EXIT.equals(alertType)) {
path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_EXIT +
"/" + queryName;
} else if (GeoServices.ALERT_TYPE_SPEED.equals(alertType)) {
path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_SPEED +
"/";
} else if (GeoServices.ALERT_TYPE_PROXIMITY.equals(alertType)) {
path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_PROXIMITY +
"/" + queryName;
} else if (GeoServices.ALERT_TYPE_STATIONARY.equals(alertType)) {
path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_STATIONARY +
"/" + queryName;
} else if (GeoServices.ALERT_TYPE_TRAFFIC.equals(alertType)) {
path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_TRAFFIC +
"/" + queryName;
} else {
throw new GeoLocationBasedServiceException(
"Unrecognized execution plan type: " + alertType);
}
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() : "",
proxTimeObj != null ? proxTimeObj.get(0).toString() : "");
proxDisObj != null ? proxDisObj.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 {
try {
throws GeoLocationBasedServiceException {
try {
Registry registry = getGovernanceRegistry();
Resource newResource = registry.newResource();
newResource.setContent(content);
newResource.setMediaType("application/json");
for (Map.Entry<String, String> option : options.entrySet()) {
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 registry = getGovernanceRegistry();
Resource newResource = registry.newResource();
newResource.setContent(content);
newResource.setMediaType("application/json");
for (Map.Entry<String, String> option : options.entrySet()) {
newResource.addProperty(option.getKey(), option.getValue());
}
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,

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

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

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

@ -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);
}

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

@ -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
*/

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

@ -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.core.geo.geoHash.GeoCoordinate;
import org.wso2.carbon.device.mgt.common.geo.service.GeoCluster;
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,
int geohashLength) throws DeviceManagementException;
List<GeoCluster> findGeoClusters(GeoQuery geoQuery) throws DeviceManagementException;
int getDeviceCountOfTypeByStatus(String deviceType, String deviceStatus) throws DeviceManagementException;

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

@ -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.core.geo.geoHash.GeoCoordinate;
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.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,
int geohashLength) throws DeviceManagementException {
public List<GeoCluster> findGeoClusters(GeoQuery geoQuery) throws DeviceManagementException {
if (log.isDebugEnabled()) {
if (deviceType == null || deviceType.isEmpty()) {
log.debug("get information about geo clusters.");
} else {
log.debug("get information about geo clusters for device type: " + deviceType);
}
log.debug("Get information about geo clusters for query: " + new Gson().toJson(geoQuery));
}
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);