Fixed issue in Geo fencing

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

@@ -29,6 +29,7 @@ import org.wso2.carbon.analytics.dataservice.commons.SortType;
 import org.wso2.carbon.analytics.datasource.commons.Record;
 import org.wso2.carbon.analytics.datasource.commons.exception.AnalyticsException;
 import org.wso2.carbon.context.CarbonContext;
+import org.wso2.carbon.device.mgt.common.Device;
 import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
 import org.wso2.carbon.device.mgt.common.DeviceManagementConstants.GeoServices;
 import org.wso2.carbon.device.mgt.common.DeviceManagementException;
@@ -163,17 +164,20 @@ public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
                 return Response.status(Response.Status.UNAUTHORIZED.getStatusCode()).build();
             }
 
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername()
-            );
-
             DeviceIdentifier identifier = new DeviceIdentifier();
             identifier.setId(deviceId);
             identifier.setType(deviceType);
 
+            Device device = DeviceMgtAPIUtils.getDeviceManagementService().getDevice(identifier, false);
+            if (device == null || device.getEnrolmentInfo() == null) {
+                if (log.isDebugEnabled()) {
+                    log.debug("Device not found: " + identifier.toString());
+                }
+                return Response.status(Response.Status.NOT_FOUND.getStatusCode()).build();
+            }
+
             GeoLocationProviderService geoService = DeviceMgtAPIUtils.getGeoService();
-            geoService.createGeoAlert(alert, identifier, alertType);
+            geoService.createGeoAlert(alert, identifier, alertType, device.getEnrolmentInfo().getOwner());
             return Response.ok().build();
         } catch (DeviceAccessAuthorizationException | GeoLocationBasedServiceException e) {
             String error = "Error occurred while creating the geo alert for " + deviceType + " with id: " + deviceId;
@@ -181,7 +185,12 @@ public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
             return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
         } catch (AlertAlreadyExistException e) {
             String error = "A geo alert with this name already exists.";
-            log.error(error,e);
+            log.error(error, e);
+            return Response.status(Response.Status.BAD_REQUEST).entity(error).build();
+        } catch (DeviceManagementException e) {
+            String error = "Error occurred while retrieving the device enrollment info of " +
+                    deviceType + " with id: " + deviceId;
+            log.error(error, e);
             return Response.status(Response.Status.BAD_REQUEST).entity(error).build();
         }
     }
@@ -202,7 +211,7 @@ public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
             return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
         } catch (AlertAlreadyExistException e) {
             String error = "A geo alert with this name already exists.";
-            log.error(error,e);
+            log.error(error, e);
             return Response.status(Response.Status.BAD_REQUEST).entity(error).build();
         }
     }
@@ -222,17 +231,20 @@ public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
                 return Response.status(Response.Status.UNAUTHORIZED.getStatusCode()).build();
             }
 
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername()
-            );
-
             DeviceIdentifier identifier = new DeviceIdentifier();
             identifier.setId(deviceId);
             identifier.setType(deviceType);
 
+            Device device = DeviceMgtAPIUtils.getDeviceManagementService().getDevice(identifier, false);
+            if (device == null || device.getEnrolmentInfo() == null) {
+                if (log.isDebugEnabled()) {
+                    log.debug("Device not found: " + identifier.toString());
+                }
+                return Response.status(Response.Status.NOT_FOUND.getStatusCode()).build();
+            }
+
             GeoLocationProviderService geoService = DeviceMgtAPIUtils.getGeoService();
-            geoService.updateGeoAlert(alert, identifier, alertType);
+            geoService.updateGeoAlert(alert, identifier, alertType, device.getEnrolmentInfo().getOwner());
             return Response.ok().build();
         } catch (DeviceAccessAuthorizationException | GeoLocationBasedServiceException e) {
             String error = "Error occurred while creating the geo alert for " + deviceType + " with id: " + deviceId;
@@ -240,7 +252,12 @@ public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
             return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
         } catch (AlertAlreadyExistException e) {
             String error = "A geo alert with this name already exists.";
-            log.error(error,e);
+            log.error(error, e);
+            return Response.status(Response.Status.BAD_REQUEST).entity(error).build();
+        } catch (DeviceManagementException e) {
+            String error = "Error occurred while retrieving the device enrollment info of " +
+                    deviceType + " with id: " + deviceId;
+            log.error(error, e);
             return Response.status(Response.Status.BAD_REQUEST).entity(error).build();
         }
     }
@@ -260,7 +277,7 @@ public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
             return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
         } catch (AlertAlreadyExistException e) {
             String error = "A geo alert with this name already exists.";
-            log.error(error,e);
+            log.error(error, e);
             return Response.status(Response.Status.BAD_REQUEST).entity(error).build();
         }
     }
@@ -280,22 +297,30 @@ public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
                 return Response.status(Response.Status.UNAUTHORIZED.getStatusCode()).build();
             }
 
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername()
-            );
-
             DeviceIdentifier identifier = new DeviceIdentifier();
             identifier.setId(deviceId);
             identifier.setType(deviceType);
 
+            Device device = DeviceMgtAPIUtils.getDeviceManagementService().getDevice(identifier, false);
+            if (device == null || device.getEnrolmentInfo() == null) {
+                if (log.isDebugEnabled()) {
+                    log.debug("Device not found: " + identifier.toString());
+                }
+                return Response.status(Response.Status.NOT_FOUND.getStatusCode()).build();
+            }
+
             GeoLocationProviderService geoService = DeviceMgtAPIUtils.getGeoService();
-            geoService.removeGeoAlert(alertType, identifier, queryName);
+            geoService.removeGeoAlert(alertType, identifier, queryName, device.getEnrolmentInfo().getOwner());
             return Response.ok().build();
         } catch (DeviceAccessAuthorizationException | GeoLocationBasedServiceException e) {
             String error = "Error occurred while removing the geo alert for " + deviceType + " with id: " + deviceId;
             log.error(error, e);
             return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
+        } catch (DeviceManagementException e) {
+            String error = "Error occurred while retrieving the device enrollment info of " +
+                    deviceType + " with id: " + deviceId;
+            log.error(error, e);
+            return Response.status(Response.Status.BAD_REQUEST).entity(error).build();
         }
     }
 
@@ -329,34 +354,37 @@ public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
                 return Response.status(Response.Status.UNAUTHORIZED.getStatusCode()).build();
             }
 
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername()
-            );
-
             DeviceIdentifier identifier = new DeviceIdentifier();
             identifier.setId(deviceId);
             identifier.setType(deviceType);
 
+            Device device = DeviceMgtAPIUtils.getDeviceManagementService().getDevice(identifier, false);
+            if (device == null || device.getEnrolmentInfo() == null) {
+                if (log.isDebugEnabled()) {
+                    log.debug("Device not found: " + identifier.toString());
+                }
+                return Response.status(Response.Status.NOT_FOUND.getStatusCode()).build();
+            }
+
             GeoLocationProviderService geoService = DeviceMgtAPIUtils.getGeoService();
 
             if (GeoServices.ALERT_TYPE_WITHIN.equals(alertType)) {
-                List<GeoFence> alerts = geoService.getWithinAlerts(identifier);
+                List<GeoFence> alerts = geoService.getWithinAlerts(identifier, device.getEnrolmentInfo().getOwner());
                 return Response.ok().entity(alerts).build();
             } else if (GeoServices.ALERT_TYPE_EXIT.equals(alertType)) {
-                List<GeoFence> alerts = geoService.getExitAlerts(identifier);
+                List<GeoFence> alerts = geoService.getExitAlerts(identifier, device.getEnrolmentInfo().getOwner());
                 return Response.ok().entity(alerts).build();
             } else if (GeoServices.ALERT_TYPE_SPEED.equals(alertType)) {
-                String result = geoService.getSpeedAlerts(identifier);
+                String result = geoService.getSpeedAlerts(identifier, device.getEnrolmentInfo().getOwner());
                 return Response.ok().entity(result).build();
             } else if (GeoServices.ALERT_TYPE_PROXIMITY.equals(alertType)) {
-                String result = geoService.getProximityAlerts(identifier);
+                String result = geoService.getProximityAlerts(identifier, device.getEnrolmentInfo().getOwner());
                 return Response.ok().entity(result).build();
             } else if (GeoServices.ALERT_TYPE_STATIONARY.equals(alertType)) {
-                List<GeoFence> alerts = geoService.getStationaryAlerts(identifier);
+                List<GeoFence> alerts = geoService.getStationaryAlerts(identifier, device.getEnrolmentInfo().getOwner());
                 return Response.ok().entity(alerts).build();
             } else if (GeoServices.ALERT_TYPE_TRAFFIC.equals(alertType)) {
-                List<GeoFence> alerts = geoService.getTrafficAlerts(identifier);
+                List<GeoFence> alerts = geoService.getTrafficAlerts(identifier, device.getEnrolmentInfo().getOwner());
                 return Response.ok().entity(alerts).build();
             }
             return null;
@@ -364,6 +392,11 @@ public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
             String error = "Error occurred while getting the geo alerts for " + deviceType + " with id: " + deviceId;
             log.error(error, e);
             return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
+        } catch (DeviceManagementException e) {
+            String error = "Error occurred while retrieving the device enrollment info of " +
+                    deviceType + " with id: " + deviceId;
+            log.error(error, e);
+            return Response.status(Response.Status.BAD_REQUEST).entity(error).build();
         }
     }
 

components/device-mgt/org.wso2.carbon.device.mgt.common/src/main/java/org/wso2/carbon/device/mgt/common/DeviceManagementConstants.java

@@ -105,7 +105,7 @@ public final class DeviceManagementConstants {
         public static final String ALERT_TYPE_PROXIMITY = "Proximity";
         public static final String ALERT_TYPE_STATIONARY = "Stationery";
         public static final String ALERT_TYPE_TRAFFIC = "Traffic";
-        public static final String REGISTRY_PATH_FOR_ALERTS = "/_system/governance/geo/alerts/";
+        public static final String REGISTRY_PATH_FOR_ALERTS = "/geo/alerts/";
         public static final String PROXIMITY_DISTANCE = "proximityDistance";
         public static final String PROXIMITY_TIME = "proximityTime";
         public static final String STATIONARY_NAME = "stationeryName";

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

@@ -28,45 +28,45 @@ import java.util.List;
  */
 public interface GeoLocationProviderService {
 
-    List<GeoFence> getWithinAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException;
+    List<GeoFence> getWithinAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException;
 
     List<GeoFence> getWithinAlerts() throws GeoLocationBasedServiceException;
 
-    List<GeoFence> getExitAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException;
+    List<GeoFence> getExitAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException;
 
     List<GeoFence> getExitAlerts() throws GeoLocationBasedServiceException;
 
-    boolean createGeoAlert(Alert alert, DeviceIdentifier identifier, String alertType)
+    boolean createGeoAlert(Alert alert, DeviceIdentifier identifier, String alertType, String owner)
             throws GeoLocationBasedServiceException, AlertAlreadyExistException;
 
     boolean createGeoAlert(Alert alert, String alertType)
             throws GeoLocationBasedServiceException,AlertAlreadyExistException;
 
-    boolean updateGeoAlert(Alert alert, DeviceIdentifier identifier, String alertType)
+    boolean updateGeoAlert(Alert alert, DeviceIdentifier identifier, String alertType, String owner)
             throws GeoLocationBasedServiceException, AlertAlreadyExistException;
 
     boolean updateGeoAlert(Alert alert, String alertType)
             throws GeoLocationBasedServiceException,AlertAlreadyExistException;
 
-    boolean removeGeoAlert(String alertType, DeviceIdentifier identifier, String queryName)
+    boolean removeGeoAlert(String alertType, DeviceIdentifier identifier, String queryName, String owner)
             throws GeoLocationBasedServiceException;
 
     boolean removeGeoAlert(String alertType, String queryName)
             throws GeoLocationBasedServiceException;
 
-    String getSpeedAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException;
+    String getSpeedAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException;
 
     String getSpeedAlerts() throws GeoLocationBasedServiceException;
 
-    String getProximityAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException;
+    String getProximityAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException;
 
     String getProximityAlerts() throws GeoLocationBasedServiceException;
 
-    List<GeoFence> getStationaryAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException;
+    List<GeoFence> getStationaryAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException;
 
     List<GeoFence> getStationaryAlerts() throws GeoLocationBasedServiceException;
 
-    List<GeoFence> getTrafficAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException;
+    List<GeoFence> getTrafficAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException;
 
     List<GeoFence> getTrafficAlerts() throws GeoLocationBasedServiceException;
 }

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

@@ -55,7 +55,6 @@ import org.wso2.carbon.registry.api.Resource;
 import javax.net.ssl.KeyManagerFactory;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.TrustManagerFactory;
-import javax.persistence.EntityExistsException;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -114,16 +113,16 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
     private static final String SSLV3 = "SSLv3";
 
     @Override
-    public List<GeoFence> getWithinAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException {
+    public List<GeoFence> getWithinAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException {
 
         Registry registry = getGovernanceRegistry();
         String registryPath = GeoServices.REGISTRY_PATH_FOR_ALERTS +
-                GeoServices.ALERT_TYPE_WITHIN + "/" + identifier.getId() + "/";
+                GeoServices.ALERT_TYPE_WITHIN + "/" + owner + "/" + identifier.getId() + "/";
         Resource resource;
         try {
             resource = registry.get(registryPath);
         } catch (RegistryException e) {
-            log.error("Error while reading the registry path: " + registryPath);
+            log.error("Error while reading the registry path: " + registryPath + ". Error: " + e.getMessage());
             return null;
         }
 
@@ -171,7 +170,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
         try {
             resource = registry.get(registryPath);
         } catch (RegistryException e) {
-            log.error("Error while reading the registry path: " + registryPath);
+            log.error("Error while reading the registry path: " + registryPath + ". Error: " + e.getMessage());
             return Collections.emptyList();
         }
 
@@ -209,16 +208,16 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
     }
 
     @Override
-    public List<GeoFence> getExitAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException {
+    public List<GeoFence> getExitAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException {
 
         Registry registry = getGovernanceRegistry();
         String registryPath = GeoServices.REGISTRY_PATH_FOR_ALERTS +
-                GeoServices.ALERT_TYPE_EXIT + "/" + identifier.getId() + "/";
+                GeoServices.ALERT_TYPE_EXIT + "/" + owner + "/" + identifier.getId() + "/";
         Resource resource;
         try {
             resource = registry.get(registryPath);
         } catch (RegistryException e) {
-            log.error("Error while reading the registry path: " + registryPath);
+            log.error("Error while reading the registry path: " + registryPath + ". Error: " + e.getMessage());
             return null;
         }
 
@@ -266,7 +265,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
         try {
             resource = registry.get(registryPath);
         } catch (RegistryException e) {
-            log.error("Error while reading the registry path: " + registryPath);
+            log.error("Error while reading the registry path: " + registryPath + ". Error: " + e.getMessage());
             return Collections.emptyList();
         }
 
@@ -304,9 +303,9 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
     }
 
     @Override
-    public boolean createGeoAlert(Alert alert, DeviceIdentifier identifier, String alertType)
+    public boolean createGeoAlert(Alert alert, DeviceIdentifier identifier, String alertType, String owner)
             throws GeoLocationBasedServiceException, AlertAlreadyExistException {
-        return saveGeoAlert(alert, identifier, alertType, false);
+        return saveGeoAlert(alert, identifier, alertType, false, owner);
     }
 
     @Override
@@ -316,9 +315,9 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
     }
 
     @Override
-    public boolean updateGeoAlert(Alert alert, DeviceIdentifier identifier, String alertType)
+    public boolean updateGeoAlert(Alert alert, DeviceIdentifier identifier, String alertType, String owner)
             throws GeoLocationBasedServiceException, AlertAlreadyExistException {
-        return saveGeoAlert(alert, identifier, alertType, true);
+        return saveGeoAlert(alert, identifier, alertType, true, owner);
     }
 
     @Override
@@ -327,7 +326,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
         return saveGeoAlert(alert, alertType, true);
     }
 
-    public boolean saveGeoAlert(Alert alert, String alertType, boolean isUpdate)
+    private boolean saveGeoAlert(Alert alert, String alertType, boolean isUpdate)
             throws GeoLocationBasedServiceException,AlertAlreadyExistException {
 
         Type type = new TypeToken<Map<String, String>>() {
@@ -434,7 +433,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
 
     }
 
-    public boolean saveGeoAlert(Alert alert, DeviceIdentifier identifier, String alertType, boolean isUpdate)
+    private boolean saveGeoAlert(Alert alert, DeviceIdentifier identifier, String alertType, boolean isUpdate, String owner)
             throws GeoLocationBasedServiceException, AlertAlreadyExistException {
 
         Type type = new TypeToken<Map<String, String>>() {
@@ -483,8 +482,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
         try {
             ExecutionPlanConfigurationDto[] allActiveExecutionPlanConfigs = null;
             String activeExecutionPlan = null;
-            String executionPlanName = getExecutionPlanName(alertType, alert.getQueryName(),
+            String executionPlanName = getExecutionPlanName(alertType, alert.getQueryName(), identifier.getId(), owner);
-                    identifier.getId());
             eventprocessorStub = getEventProcessorAdminServiceStub();
             String parsedTemplate = parseTemplate(alertType, parseMap);
             String validationResponse = eventprocessorStub.validateExecutionPlan(parsedTemplate);
@@ -507,7 +505,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
                                     + executionPlanName);
                         }
                     }
-                    updateRegistry(getRegistryPath(alertType, identifier, alert.getQueryName()), identifier, content,
+                    updateRegistry(getRegistryPath(alertType, identifier, alert.getQueryName(), owner), identifier, content,
                             options);
                     eventprocessorStub.deployExecutionPlan(parsedTemplate);
                 }
@@ -545,27 +543,27 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
         }
     }
 
-    private String getRegistryPath(String alertType, DeviceIdentifier identifier, String queryName)
+    private String getRegistryPath(String alertType, DeviceIdentifier identifier, String queryName, String owner)
             throws GeoLocationBasedServiceException {
         String path = "";
         if (GeoServices.ALERT_TYPE_WITHIN.equals(alertType)) {
             path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_WITHIN +
-                    "/" + identifier.getId() + "/" + queryName;
+                    "/" + owner + "/" + identifier.getId() + "/" + queryName;
         } else if (GeoServices.ALERT_TYPE_EXIT.equals(alertType)) {
             path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_EXIT +
-                    "/" + identifier.getId() + "/" + queryName;
+                    "/" + owner + "/" + identifier.getId() + "/" + queryName;
         } else if (GeoServices.ALERT_TYPE_SPEED.equals(alertType)) {
             path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_SPEED +
-                    "/" + identifier.getId();
+                    "/" + owner + "/" + identifier.getId();
         } else if (GeoServices.ALERT_TYPE_PROXIMITY.equals(alertType)) {
             path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_PROXIMITY +
-                    "/" + identifier.getId() + "/" + queryName;
+                    "/" + owner + "/" + identifier.getId() + "/" + queryName;
         } else if (GeoServices.ALERT_TYPE_STATIONARY.equals(alertType)) {
             path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_STATIONARY +
-                    "/" + identifier.getId() + "/" + queryName;
+                    "/" + owner + "/" + identifier.getId() + "/" + queryName;
         } else if (GeoServices.ALERT_TYPE_TRAFFIC.equals(alertType)) {
             path = GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_TRAFFIC +
-                    "/" + identifier.getId() + "/" + queryName;
+                    "/" + owner + "/" + identifier.getId() + "/" + queryName;
         } else {
             throw new GeoLocationBasedServiceException(
                     "Unrecognized execution plan type: " + alertType);
@@ -601,11 +599,11 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
             return path;
         }
 
-    private String getExecutionPlanName(String alertType, String queryName, String deviceId) {
+    private String getExecutionPlanName(String alertType, String queryName, String deviceId, String owner) {
         if ("Traffic".equals(alertType)) {
             return "Geo-ExecutionPlan-Traffic_" + queryName + "_alert";
         } else {
-            return "Geo-ExecutionPlan-" + alertType + "_" + queryName + "---_" + deviceId + "_alert";
+            return "Geo-ExecutionPlan-" + alertType + "_" + queryName + "---_" + owner + "_" + deviceId + "_alert";
         }
     }
 
@@ -621,10 +619,10 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
     }
 
     @Override
-    public boolean removeGeoAlert(String alertType, DeviceIdentifier identifier, String queryName)
+    public boolean removeGeoAlert(String alertType, DeviceIdentifier identifier, String queryName, String owner)
             throws GeoLocationBasedServiceException {
-        removeFromRegistry(alertType, identifier, queryName);
+        removeFromRegistry(alertType, identifier, queryName, owner);
-        String executionPlanName = getExecutionPlanName(alertType, queryName, identifier.getId());
+        String executionPlanName = getExecutionPlanName(alertType, queryName, identifier.getId(), owner);
         EventProcessorAdminServiceStub eventprocessorStub = null;
         try {
             eventprocessorStub = getEventProcessorAdminServiceStub();
@@ -674,11 +672,11 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
         }
     }
 
-    private void removeFromRegistry(String alertType, DeviceIdentifier identifier, String queryName)
+    private void removeFromRegistry(String alertType, DeviceIdentifier identifier, String queryName, String owner)
             throws GeoLocationBasedServiceException {
         String path = "unknown";
         try {
-            path = getRegistryPath(alertType, identifier, queryName);
+            path = getRegistryPath(alertType, identifier, queryName, owner);
             getGovernanceRegistry().delete(path);
         } catch (RegistryException e) {
             throw new GeoLocationBasedServiceException(
@@ -746,11 +744,11 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
     }
 
     @Override
-    public String getSpeedAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException {
+    public String getSpeedAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException {
         try {
             Registry registry = getGovernanceRegistry();
             Resource resource = registry.get(GeoServices.REGISTRY_PATH_FOR_ALERTS +
-                                                     GeoServices.ALERT_TYPE_SPEED + "/" + identifier.getId());
+                    GeoServices.ALERT_TYPE_SPEED + "/" + owner + "/" + identifier.getId());
             if (resource == null) {
                 return "{'content': false}";
             }
@@ -782,12 +780,11 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
     }
 
     @Override
-    public String getProximityAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException {
+    public String getProximityAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException {
         try {
             Registry registry = getGovernanceRegistry();
-            Resource resource = registry.get(GeoServices.REGISTRY_PATH_FOR_ALERTS +
+            Resource resource = registry.get(GeoServices.REGISTRY_PATH_FOR_ALERTS + GeoServices.ALERT_TYPE_PROXIMITY +
-                                                     GeoServices.ALERT_TYPE_PROXIMITY
+                    "/" + owner + "/" + identifier.getId());
-                                                     + "/" + identifier.getId());
             if (resource != null) {
                 Properties props = resource.getProperties();
 
@@ -830,11 +827,11 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
 
 
     @Override
-    public List<GeoFence> getStationaryAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException {
+    public List<GeoFence> getStationaryAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException {
 
         Registry registry = getGovernanceRegistry();
         String registryPath = GeoServices.REGISTRY_PATH_FOR_ALERTS +
-                GeoServices.ALERT_TYPE_STATIONARY + "/" + identifier.getId() + "/";
+                GeoServices.ALERT_TYPE_STATIONARY + "/" + owner + "/" + identifier.getId() + "/";
         Resource resource;
         try {
             resource = registry.get(registryPath);
@@ -933,10 +930,10 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
     }
 
     @Override
-    public List<GeoFence> getTrafficAlerts(DeviceIdentifier identifier) throws GeoLocationBasedServiceException {
+    public List<GeoFence> getTrafficAlerts(DeviceIdentifier identifier, String owner) throws GeoLocationBasedServiceException {
         Registry registry = getGovernanceRegistry();
         String registryPath = GeoServices.REGISTRY_PATH_FOR_ALERTS +
-                GeoServices.ALERT_TYPE_STATIONARY + "/" + identifier.getId() + "/";
+                GeoServices.ALERT_TYPE_STATIONARY + "/" + owner + "/" + identifier.getId() + "/";
         Resource resource;
         try {
             resource = registry.get(registryPath);

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/geo/service/GeoLocationProviderServiceTest.java

@@ -19,21 +19,17 @@
 
 package org.wso2.carbon.device.mgt.core.geo.service;
 
-import org.apache.axis2.AxisFault;
 import org.mockito.Mockito;
-
 import org.testng.Assert;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 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.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.GeoFence;
 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.core.TestDeviceManagementService;
 import org.wso2.carbon.device.mgt.core.common.TestDataHolder;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
@@ -59,70 +55,76 @@ public class GeoLocationProviderServiceTest {
     private static final String SAMPLE_STATIONARY_TIME = "1500";
     private static final String SAMPLE_FLUCTUATION_RADIUS = "2000";
 
-    private EventProcessorAdminServiceStub mockEventProcessorAdminServiceStub;
     private GeoLocationProviderServiceImpl geoLocationProviderServiceImpl;
     private ExecutionPlanConfigurationDto[] mockExecutionPlanConfigurationDto = new ExecutionPlanConfigurationDto[1];
-
+    private Device device;
+    
     @BeforeClass
     public void init() throws Exception {
         initMocks();
-        enrollDevice();
+        device = enrollDevice();
     }
 
-    @Test (description = "Create a sample geo exit-alert with relevant details.")
+    @Test(description = "Create a sample geo exit-alert with relevant details.")
     public void createGeoExitAlert() throws GeoLocationBasedServiceException, AlertAlreadyExistException {
-         Boolean result = geoLocationProviderServiceImpl.
+        Boolean result = geoLocationProviderServiceImpl.
-                createGeoAlert(getExitAlert(), getDeviceIdentifier(), DeviceManagementConstants.GeoServices.ALERT_TYPE_EXIT);
+                createGeoAlert(getExitAlert(), getDeviceIdentifier(),
+                        DeviceManagementConstants.GeoServices.ALERT_TYPE_EXIT, device.getEnrolmentInfo().getOwner());
         Assert.assertEquals(result, Boolean.TRUE);
     }
 
-    @Test (description = "Create a sample geo within-alert with relevant details.")
+    @Test(description = "Create a sample geo within-alert with relevant details.")
     public void createGeoWithinAlert() throws GeoLocationBasedServiceException, AlertAlreadyExistException {
-         Boolean result = geoLocationProviderServiceImpl.
+        Boolean result = geoLocationProviderServiceImpl.
-                createGeoAlert(getWithinAlert(), getDeviceIdentifier(), DeviceManagementConstants.GeoServices.ALERT_TYPE_WITHIN);
+                createGeoAlert(getWithinAlert(), getDeviceIdentifier(),
+                        DeviceManagementConstants.GeoServices.ALERT_TYPE_WITHIN, device.getEnrolmentInfo().getOwner());
         Assert.assertEquals(result, Boolean.TRUE);
     }
 
-    @Test (description = "Create a sample geo proximity-alert with relevant details.")
+    @Test(description = "Create a sample geo proximity-alert with relevant details.")
     public void createGeoProximityAlert() throws GeoLocationBasedServiceException, AlertAlreadyExistException {
         Boolean result = geoLocationProviderServiceImpl.
-                createGeoAlert(getProximityAlert(), getDeviceIdentifier(), DeviceManagementConstants.GeoServices.ALERT_TYPE_PROXIMITY);
+                createGeoAlert(getProximityAlert(), getDeviceIdentifier(),
+                        DeviceManagementConstants.GeoServices.ALERT_TYPE_PROXIMITY, device.getEnrolmentInfo().getOwner());
         Assert.assertEquals(result, Boolean.TRUE);
     }
 
-    @Test (description = "Create a sample geo speed-alert with relevant details.")
+    @Test(description = "Create a sample geo speed-alert with relevant details.")
     public void createGeoSpeedAlert() throws GeoLocationBasedServiceException, AlertAlreadyExistException {
         Boolean result = geoLocationProviderServiceImpl.
-                createGeoAlert(getSpeedAlert(), getDeviceIdentifier(), DeviceManagementConstants.GeoServices.ALERT_TYPE_SPEED);
+                createGeoAlert(getSpeedAlert(), getDeviceIdentifier(),
+                        DeviceManagementConstants.GeoServices.ALERT_TYPE_SPEED, device.getEnrolmentInfo().getOwner());
         Assert.assertEquals(result, Boolean.TRUE);
     }
 
-    @Test (description = "Create a sample geo stationary-alert with relevant details.")
+    @Test(description = "Create a sample geo stationary-alert with relevant details.")
     public void createGeoStationaryAlert() throws GeoLocationBasedServiceException, AlertAlreadyExistException {
         Boolean result = geoLocationProviderServiceImpl.
-                createGeoAlert(getStationaryAlert(), getDeviceIdentifier(), DeviceManagementConstants.GeoServices.ALERT_TYPE_STATIONARY);
+                createGeoAlert(getStationaryAlert(), getDeviceIdentifier(),
+                        DeviceManagementConstants.GeoServices.ALERT_TYPE_STATIONARY, device.getEnrolmentInfo().getOwner());
         Assert.assertEquals(result, Boolean.TRUE);
     }
 
-    @Test (description = "Create a sample geo traffic-alert with relevant details.")
+    @Test(description = "Create a sample geo traffic-alert with relevant details.")
     public void createGeoTrafficAlert() throws GeoLocationBasedServiceException, AlertAlreadyExistException {
         Boolean result = geoLocationProviderServiceImpl.
-                createGeoAlert(getTrafficAlert(), getDeviceIdentifier(), DeviceManagementConstants.GeoServices.ALERT_TYPE_TRAFFIC);
+                createGeoAlert(getTrafficAlert(), getDeviceIdentifier(),
+                        DeviceManagementConstants.GeoServices.ALERT_TYPE_TRAFFIC, device.getEnrolmentInfo().getOwner());
         Assert.assertEquals(result, Boolean.TRUE);
     }
 
     @Test(dependsOnMethods = "createGeoSpeedAlert", description = "retrieve saved geo speed-alert.")
     public void getGeoSpeedAlerts() throws GeoLocationBasedServiceException {
         String result;
-        result = geoLocationProviderServiceImpl.getSpeedAlerts(getDeviceIdentifier());
+        result = geoLocationProviderServiceImpl.getSpeedAlerts(getDeviceIdentifier(), device.getEnrolmentInfo().getOwner());
         Assert.assertNotNull(result);
         Assert.assertEquals(result, "{'speedLimit':" + SAMPLE_SPEED_ALERT_VALUE + "}");
     }
 
-    @Test(dependsOnMethods = "createGeoTrafficAlert" , description = "retrieve saved geo exit-alert.")
+    @Test(dependsOnMethods = "createGeoTrafficAlert", description = "retrieve saved geo exit-alert.")
     public void getGeoTrafficAlerts() throws GeoLocationBasedServiceException {
         List<GeoFence> geoFences;
-        geoFences = geoLocationProviderServiceImpl.getTrafficAlerts(getDeviceIdentifier());
+        geoFences = geoLocationProviderServiceImpl.getTrafficAlerts(getDeviceIdentifier(), device.getEnrolmentInfo().getOwner());
         Assert.assertNotNull(geoFences);
         GeoFence geoFenceNode = geoFences.get(0);
         Assert.assertEquals(geoFenceNode.getGeoJson(), "{\n" +
@@ -133,7 +135,7 @@ public class GeoLocationProviderServiceTest {
     @Test(dependsOnMethods = "createGeoStationaryAlert", description = "retrieve saved geo stationary-alert.")
     public void getGeoStationaryAlerts() throws GeoLocationBasedServiceException {
         List<GeoFence> geoFences;
-        geoFences = geoLocationProviderServiceImpl.getStationaryAlerts(getDeviceIdentifier());
+        geoFences = geoLocationProviderServiceImpl.getStationaryAlerts(getDeviceIdentifier(), device.getEnrolmentInfo().getOwner());
         Assert.assertNotNull(geoFences);
         GeoFence geoFenceNode = geoFences.get(0);
         Assert.assertEquals(geoFenceNode.getAreaName(), SAMPLE_AREA_NAME);
@@ -142,7 +144,7 @@ public class GeoLocationProviderServiceTest {
     }
 
     private void initMocks() throws JWTClientException, RemoteException {
-        mockEventProcessorAdminServiceStub = Mockito.mock(EventProcessorAdminServiceStub.class);
+        EventProcessorAdminServiceStub mockEventProcessorAdminServiceStub = Mockito.mock(EventProcessorAdminServiceStub.class);
         geoLocationProviderServiceImpl = Mockito.mock(GeoLocationProviderServiceImpl.class, Mockito.CALLS_REAL_METHODS);
         mockExecutionPlanConfigurationDto[0] = Mockito.mock(ExecutionPlanConfigurationDto.class);
         Mockito.doReturn(mockEventProcessorAdminServiceStub).
@@ -156,8 +158,8 @@ public class GeoLocationProviderServiceTest {
 
     private DeviceIdentifier getDeviceIdentifier() {
         DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
-        deviceIdentifier.setId("1234");
+        deviceIdentifier.setId(device.getDeviceIdentifier());
-        deviceIdentifier.setType("TEST");
+        deviceIdentifier.setType(device.getType());
         return deviceIdentifier;
     }
 
@@ -200,7 +202,7 @@ public class GeoLocationProviderServiceTest {
     }
 
     private Alert getSpeedAlert() {
-        Alert alert =  new Alert();
+        Alert alert = new Alert();
         alert.setDeviceId(DEVICE_ID);
         alert.setParseData("{\n" +
                 "  \"" + DeviceManagementConstants.GeoServices.GEO_FENCE_GEO_JSON + "\": \"" + SAMPLE_GEO_JSON + "\",\n" +
@@ -226,7 +228,7 @@ public class GeoLocationProviderServiceTest {
         Alert alert = new Alert();
         alert.setDeviceId(DEVICE_ID);
         alert.setParseData("{\n" +
-                "  \"" + DeviceManagementConstants.GeoServices.GEO_FENCE_GEO_JSON +"\": \"" + SAMPLE_GEO_JSON + "\"\n" +
+                "  \"" + DeviceManagementConstants.GeoServices.GEO_FENCE_GEO_JSON + "\": \"" + SAMPLE_GEO_JSON + "\"\n" +
                 "}");
         alert.setCustomName(SAMPLE_AREA_NAME);
         alert.setExecutionPlan("EXECUTION_PLAN");
@@ -234,7 +236,7 @@ public class GeoLocationProviderServiceTest {
         return alert;
     }
 
-    private void enrollDevice() throws Exception {
+    private Device enrollDevice() throws Exception {
         DeviceIdentifier deviceIdentifier = new DeviceIdentifier(DEVICE_ID, DEVICE_TYPE);
         Device device = TestDataHolder.generateDummyDeviceData(deviceIdentifier);
         DeviceManagementProviderService deviceMgtService = DeviceManagementDataHolder.getInstance().
@@ -245,9 +247,11 @@ public class GeoLocationProviderServiceTest {
 
         Device returnedDevice = deviceMgtService.getDevice(deviceIdentifier);
 
-            if (!returnedDevice.getDeviceIdentifier().equals(deviceIdentifier.getId())) {
+        if (!returnedDevice.getDeviceIdentifier().equals(deviceIdentifier.getId())) {
-                throw new Exception("Incorrect device with ID - " + device.getDeviceIdentifier() + " returned!");
+            throw new Exception("Incorrect device with ID - " + device.getDeviceIdentifier() + " returned!");
-            }
         }
+        
+        return returnedDevice;
+    }
 
 }

components/device-mgt/org.wso2.carbon.device.mgt.ui/src/main/resources/jaggeryapps/devicemgt/app/units/cdmf.unit.geo-dashboard/geo-dashboard.hbs

@@ -522,7 +522,7 @@
                 {{#if geoServicesEnabled}}
                 <h6>Speed<span class="label label-primary pull-right"><span id="speed"></span> km/h</span></h6>
                 <h6>Heading<span id="heading" class="label label-primary pull-right"></span></h6>
-                <button type="button" class="btn btn-info btn-xs" onClick="toggleSpeedGraph();return false;">Speed Graph</button>
+                <!--<button type="button" class="btn btn-info btn-xs" onClick="toggleSpeedGraph();return false;">Speed Graph</button>-->
                 <button type="button" class="btn btn-info btn-xs" onClick="focusOnRecentHistorySpatialObject();return false;">Recent History</button>
                 <button type="button" class="btn btn-info btn-xs" onClick="popupDateRange();">Full History</button>
                 {{/if}}

components/device-mgt/org.wso2.carbon.device.mgt.ui/src/main/resources/jaggeryapps/devicemgt/app/units/cdmf.unit.geo-dashboard/public/js/websocket.js

@@ -78,7 +78,7 @@ function initializeGeoLocation(geoFencingEnabled) {
         geoPublicUri = geoCharts.data("geo-public-uri");
         webSocketURL = wsEndPoint + "iot.per.device.stream.geo.FusedSpatialEvent/1.0.0?"
             + "deviceId=" + deviceId + "&deviceType=" + deviceType + "&websocketToken=" + wsToken;
-        alertWebSocketURL = wsEndPoint + "iot.per.device.stream.geo.AlertsNotifications/1.0.0?"
+        alertWebSocketURL = wsEndPoint + "iot.per.device.stream.geo.AlertNotifications/1.0.0?"
             + "deviceId=" + deviceId + "&deviceType=" + deviceType + "&websocketToken=" + wsToken;
         $("#proximity_alert").hide();
 

components/device-mgt/org.wso2.carbon.device.mgt.ui/src/main/resources/jaggeryapps/devicemgt/app/units/cdmf.unit.geo-devices/geo-devices.hbs

@@ -31,28 +31,14 @@
     <div class="action-btn-container" id="location-action-bar">
     </div>
 </div>
-{{#if geoServicesEnabled}}
+
-<br>
-<br>
-<br>
-{{/if}}
 <span id="geo-charts" data-ws-endpoint="{{wsEndpoint}}" data-ws-token="{{wsToken}}" data-geo-public-uri="{{@unit.publicUri}}"
       data-device-location="{{lastLocation}}"></span>
 
 <div class="map-wrapper">
-    {{#if geoServicesEnabled}}
+    <div id="" style="height: 80vh;">
-        <div id="" style="height: 75vh;">
+        <div id="map"></div>
-            <div id="map"></div>
+    </div>
-            <div id="ws-alerts">
-                <i id="ws-alert-stream" class="fw fw-circle text-muted"></i> Alerts Stream&nbsp;
-                <i id="ws-spatial-stream" class="fw fw-circle text-muted"></i> Spatial Stream
-            </div>
-        </div>
-    {{else}}
-        <div id="" style="height: 80vh;">
-            <div id="map"></div>
-        </div>
-    {{/if}}
 
     <div id="predictionResults" style="background: darkgray;display: none;border-radius: 13px;height: 94%;padding: 0"
          class="col-md-2 pull-right">
@@ -693,13 +679,6 @@
             <div class="popover-content">
                 <h6>Information</h6>
                 <p id="information" class="bg-primary" style="margin: 0px;padding: 0px;"></p>
-                {{#if geoServicesEnabled}}
-                    <h6>Speed<span class="label label-primary pull-right"><span id="speed"></span> km/h</span></h6>
-                    <h6>Heading<span id="heading" class="label label-primary pull-right"></span></h6>
-                    <button type="button" class="btn btn-info btn-xs" onClick="toggleSpeedGraph();return false;">Speed Graph</button>
-                    <button type="button" class="btn btn-info btn-xs" onClick="showRecentAlertsHistory();return false;">Recent History</button>
-                    <button type="button" class="btn btn-info btn-xs" onClick="popupDateRange();">Full History</button>
-                {{/if}}
             </div>
         </div>
 
@@ -891,10 +870,6 @@
     {{js "js/typeahead.bundle.min.js" }}
     {{js "js/geo_remote.js" }}
     {{js "js/app.js" }}
-    {{js "js/geo_exit_fence.js" }}
-    {{js "js/geo_within.js" }}
-    {{js "js/geo_stationary.js" }}
-    {{js "js/geo_speed.js" }}
 
     {{!js "js/jquery/jquery-ui.min.js" }}
     <!-- Leaflet plugins libries -->
@@ -913,46 +888,12 @@
     {{js "js/geo_fencing.js" }}
     <script type="text/javascript">
         $(document).ready(function () {
-            initializeGeoLocation({{geoServicesEnabled}});
+            initializeGeoLocation(false);
             geoPublicUri = $("#geo-charts").data("geo-public-uri");
-            {{#if geoServicesEnabled}}
-                var geoToolsMenu = $('#location-action-bar');
-
-                var refreshMap = createGeoToolListItem('javascript:void(0);', 'Refresh', 'fw fw-refresh', geoToolsMenu, true);
-                refreshMap.addClass("geo-tools");
-                refreshMap.on("click", function(){enableRealTime({{geoServicesEnabled}});});
-
-                var viewAll = createGeoToolListItem('javascript:void(0);', 'View All', 'glyphicon glyphicon-th-list', geoToolsMenu, true);
-                viewAll.addClass("geo-tools");
-                viewAll.on("click", function(){viewAllFences();});
-
-                var realTime = createGeoToolListItem('javascript:void(0);', 'Return to Real Time View', 'fw fw-undo', geoToolsMenu, true);
-                realTime.addClass("geo-tools");
-                realTime.on("click", function(){enableRealTime({{geoServicesEnabled}});});
-                realTime.css("display", "none");
-                realTime.attr("id", "realTimeShow");
-
-                var exitAlert  = createGeoToolListItem('#', 'Add Geofence Exit Alert', 'glyphicon glyphicon-log-out', geoToolsMenu,'Exit');
-                exitAlert.addClass("geo-alert");
-                exitAlert.on("click", function(){initializeExit();});
-
-                var withinAlert = createGeoToolListItem('#', 'Add Geofence Enter Alert', 'glyphicon glyphicon-log-in', geoToolsMenu,'Within');
-                withinAlert.addClass("geo-alert");
-                withinAlert.on("click", function(){initializeWithin();});
-
-                var stationaryAlert = createGeoToolListItem('#', 'Add Stationary Alert', 'glyphicon glyphicon-link', geoToolsMenu,'Stationery');
-                stationaryAlert.addClass("geo-alert");
-                stationaryAlert.on("click", function(){initStationaryAlert();});
-
-                var speedAlert = createGeoToolListItem('#', 'Set Speed Alert', 'glyphicon glyphicon-dashboard', geoToolsMenu,'Speed');
-                speedAlert.addClass("geo-alert");
-                speedAlert.on("click", function(){initializeSpeed();});
-            {{/if}}
-
-
             $('a[data-toggle="tab"]').on('shown.bs.tab', function (e) {
                 $('#dateRangePopup.ui-dialog-content').dialog('close');
             });
         });
     </script>
+
 {{/zone}}

components/device-mgt/org.wso2.carbon.device.mgt.ui/src/main/resources/jaggeryapps/devicemgt/app/units/cdmf.unit.geo-devices/public/js/websocket.js

@@ -68,25 +68,21 @@ function initializeOnAlertWebSocket() {
 }
 
 function initializeGeoLocation(geoFencingEnabled) {
-    if (true) {
+    var geoCharts = $("#geo-charts");
-        var geoCharts = $("#geo-charts");
+    var wsEndPoint = geoCharts.data("ws-endpoint");
-        var wsEndPoint = geoCharts.data("ws-endpoint");
+    wsToken = geoCharts.data("ws-token");
-        wsToken = geoCharts.data("ws-token");
+    geoPublicUri = geoCharts.data("geo-public-uri");
-        geoPublicUri = geoCharts.data("geo-public-uri");
+    geoPublicUri = geoCharts.data("geo-public-uri");
-        geoPublicUri = geoCharts.data("geo-public-uri");
+    webSocketURL = wsEndPoint + "iot.per.device.stream.geo.FusedSpatialEvent/1.0.0?" + "&websocketToken=" + wsToken;
-        webSocketURL = wsEndPoint + "iot.per.device.stream.geo.FusedSpatialEvent/1.0.0?" + "&websocketToken=" + wsToken;
+    alertWebSocketURL = wsEndPoint + "iot.per.device.stream.geo.AlertNotifications/1.0.0?" + "&websocketToken=" + wsToken;
-        alertWebSocketURL = wsEndPoint + "iot.per.device.stream.geo.AlertsNotifications/1.0.0?" + "&websocketToken=" + wsToken;
+    $("#proximity_alert").hide();
-        $("#proximity_alert").hide();
 
-        if (geoFencingEnabled) {
+    if (geoFencingEnabled) {
-            disconnect();
+        disconnect();
-            initializeSpatialStreamWebSocket();
+        initializeSpatialStreamWebSocket();
-            initializeOnAlertWebSocket();
+        initializeOnAlertWebSocket();
-        }
-        initialLoad(geoFencingEnabled);
-    } else {
-        noty({text: 'Invalid Access! No device information provided to track!', type: 'error'});
     }
+    initialLoad(geoFencingEnabled);
 }
 
 function disconnect(){

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

@@ -1,550 +0,0 @@
-/*
- * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
- *
- * WSO2 Inc. 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.service.api;
-
-import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiOperation;
-import io.swagger.annotations.ApiParam;
-import io.swagger.annotations.ApiResponse;
-import io.swagger.annotations.ApiResponses;
-import io.swagger.annotations.Extension;
-import io.swagger.annotations.ExtensionProperty;
-import io.swagger.annotations.Info;
-import io.swagger.annotations.ResponseHeader;
-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.geo.service.Alert;
-import org.wso2.carbon.device.mgt.jaxrs.util.Constants;
-
-import javax.validation.Valid;
-import javax.validation.constraints.Size;
-import javax.ws.rs.Consumes;
-import javax.ws.rs.DELETE;
-import javax.ws.rs.GET;
-import javax.ws.rs.POST;
-import javax.ws.rs.PUT;
-import javax.ws.rs.Path;
-import javax.ws.rs.PathParam;
-import javax.ws.rs.Produces;
-import javax.ws.rs.QueryParam;
-import javax.ws.rs.core.Response;
-
-@SwaggerDefinition(
-        info = @Info(
-                version = "0.9.0",
-                title = "",
-                extensions = {
-                        @Extension(properties = {
-                                @ExtensionProperty(name = "name", value = "geo_services"),
-                                @ExtensionProperty(name = "context", value = "/api/device-mgt/v0.9/geo-services"),
-                        })
-                }
-        ),
-        tags = {
-                @Tag(name = "device_management", description = "")
-        }
-)
-@Scopes(
-        scopes = {
-                @Scope(
-                        name = "View Analytics",
-                        description = "",
-                        key = "perm:geo-service:analytics-view",
-                        permissions = {"/device-mgt/devices/owning-device/view-analytics"}
-                ),
-                @Scope(
-                        name = "Manage Alerts",
-                        description = "",
-                        key = "perm:geo-service:alerts-manage",
-                        permissions = {"/device-mgt/devices/owning-device/manage-alerts"}
-                )
-        }
-)
-@Path("/geo-services")
-@Api(value = "Geo Service",
-        description = "This carries all the resources related to the geo service functionalities.")
-public interface GeoLocationBasedService {
-    /**
-     * Retrieve Analytics for the device type
-     */
-    @GET
-    @Path("stats/{deviceType}/{deviceId}")
-    @ApiOperation(
-            consumes = "application/json",
-            produces = "application/json",
-            httpMethod = "GET",
-            value = "Retrieve Analytics for the device type",
-            notes = "",
-            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 Device Identifiers 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 getGeoDeviceStats(
-            @ApiParam(
-                    name = "deviceId",
-                    value = "The registered device Id.",
-                    required = true)
-            @PathParam("deviceId") String deviceId,
-            @ApiParam(
-                    name = "device-type",
-                    value = "The device type, such as ios, android or windows.",
-                    required = true)
-            @PathParam("deviceType")
-            @Size(max = 45)
-                    String deviceType,
-            @ApiParam(
-                    name = "from",
-                    value = "Get stats from what time",
-                    required = true)
-            @QueryParam("from") long from,
-            @ApiParam(
-                    name = "to",
-                    value = "Get stats up to what time",
-                    required = true)
-            @QueryParam("to") long to);
-
-    /**
-     * Get data to show device locations in a map
-     */
-    @GET
-    @Path("stats/device-locations")
-    @ApiOperation(
-            consumes = "application/json",
-            produces = "application/json",
-            httpMethod = "GET",
-            value = "Retrieve locations of devices",
-            notes = "",
-            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 getGeoDeviceLocations(
-            @ApiParam(
-                    name = "minLat",
-                    value = "minimum latitude",
-                    required = true)
-            @QueryParam("minLat") double minLat,
-            @ApiParam(
-                    name = "maxLat",
-                    value = "maxmimum latitude",
-                    required = true)
-            @QueryParam("maxLat") double maxLat,
-            @ApiParam(
-                    name = "minLong",
-                    value = "minimum longitude",
-                    required = true)
-            @QueryParam("minLong") double minLong,
-            @ApiParam(
-                    name = "maxLong",
-                    value = "maximum longitudeude",
-                    required = true)
-            @QueryParam("maxLong") double maxLong,
-            @ApiParam(
-                    name = "zoom",
-                    value = "zoom level",
-                    required = true)
-            @QueryParam("zoom") int zoom);
-
-
-    /**
-     * Create Geo alerts
-     */
-    @POST
-    @Path("alerts/{alertType}/{deviceType}/{deviceId}")
-    @ApiOperation(
-            consumes = "application/json",
-            produces = "application/json",
-            httpMethod = "GET",
-            value = "Create Geo alerts for the device",
-            notes = "",
-            response = Response.class,
-            tags = "Geo Service Management",
-            extensions = {
-                    @Extension(properties = {
-                            @ExtensionProperty(name = Constants.SCOPE, value = "perm:geo-service:alerts-manage")
-                    })
-            }
-    )
-    @ApiResponses(value = {
-            @ApiResponse(
-                    code = 200,
-                    message = "OK.",
-                    response = Response.class,
-                    responseHeaders = {
-                            @ResponseHeader(
-                                    name = "Content-Type",
-                                    description = "The content type of the body")
-                    }),
-            @ApiResponse(
-                    code = 400,
-                    message = "Bad Request. \n Invalid Device Identifiers 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 createGeoAlerts(
-            @ApiParam(
-                    name = "alert",
-                    value = "The alert object",
-                    required = true)
-            @Valid Alert alert,
-            @ApiParam(
-                    name = "deviceId",
-                    value = "The registered device Id.",
-                    required = true)
-            @PathParam("deviceId") String deviceId,
-            @ApiParam(
-                    name = "device-type",
-                    value = "The device type, such as ios, android or windows.",
-                    required = true)
-            @PathParam("deviceType")
-            @Size(max = 45)
-                    String deviceType,
-            @ApiParam(
-                    name = "alertType",
-                    value = "The alert type, such as Within, Speed, Stationary",
-                    required = true)
-            @PathParam("alertType") String alertType);
-
-    /**
-     * Update Geo alerts
-     */
-    @PUT
-    @Path("alerts/{alertType}/{deviceType}/{deviceId}")
-    @ApiOperation(
-            consumes = "application/json",
-            produces = "application/json",
-            httpMethod = "GET",
-            value = "Update Geo alerts for the device",
-            notes = "",
-            response = Response.class,
-            tags = "Geo Service Management",
-            extensions = {
-                    @Extension(properties = {
-                            @ExtensionProperty(name = Constants.SCOPE, value = "perm:geo-service:alerts-manage")
-                    })
-            }
-    )
-    @ApiResponses(value = {
-            @ApiResponse(
-                    code = 200,
-                    message = "OK.",
-                    response = Response.class,
-                    responseHeaders = {
-                            @ResponseHeader(
-                                    name = "Content-Type",
-                                    description = "The content type of the body")
-                    }),
-            @ApiResponse(
-                    code = 400,
-                    message = "Bad Request. \n Invalid Device Identifiers 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 updateGeoAlerts(
-            @ApiParam(
-                    name = "alert",
-                    value = "The alert object",
-                    required = true)
-            @Valid Alert alert,
-            @ApiParam(
-                    name = "deviceId",
-                    value = "The registered device Id.",
-                    required = true)
-            @PathParam("deviceId") String deviceId,
-            @ApiParam(
-                    name = "device-type",
-                    value = "The device type, such as ios, android or windows.",
-                    required = true)
-            @PathParam("deviceType")
-            @Size(max = 45)
-                    String deviceType,
-            @ApiParam(
-                    name = "alertType",
-                    value = "The alert type, such as Within, Speed, Stationary",
-                    required = true)
-            @PathParam("alertType") String alertType);
-
-    /**
-     * Retrieve Geo alerts
-     */
-    @GET
-    @Path("alerts/{alertType}/{deviceType}/{deviceId}")
-    @ApiOperation(
-            consumes = "application/json",
-            produces = "application/json",
-            httpMethod = "GET",
-            value = "Retrieve Geo alerts for the device",
-            notes = "",
-            response = Response.class,
-            tags = "Geo Service Management",
-            extensions = {
-                    @Extension(properties = {
-                            @ExtensionProperty(name = Constants.SCOPE, value = "perm:geo-service:alerts-manage")
-                    })
-            }
-    )
-    @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 Device Identifiers 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 getGeoAlerts(
-            @ApiParam(
-                    name = "deviceId",
-                    value = "The registered device Id.",
-                    required = true)
-            @PathParam("deviceId") String deviceId,
-            @ApiParam(
-                    name = "device-type",
-                    value = "The device type, such as ios, android or windows.",
-                    required = true)
-            @PathParam("deviceType")
-            @Size(max = 45)
-                    String deviceType,
-            @ApiParam(
-                    name = "alertType",
-                    value = "The alert type, such as Within, Speed, Stationary",
-                    required = true)
-            @PathParam("alertType") String alertType);
-
-    /**
-     * Retrieve Geo alerts history
-     */
-    @GET
-    @Path("alerts/history/{deviceType}/{deviceId}")
-    @ApiOperation(
-            consumes = "application/json",
-            produces = "application/json",
-            httpMethod = "GET",
-            value = "Retrieve Geo alerts history for the device",
-            notes = "",
-            response = Response.class,
-            tags = "Geo Service Management",
-            extensions = {
-                    @Extension(properties = {
-                            @ExtensionProperty(name = Constants.SCOPE, value = "perm:geo-service:alerts-manage")
-                    })
-            }
-    )
-    @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 Device Identifiers 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 getGeoAlertsHistory(
-            @ApiParam(
-                    name = "deviceId",
-                    value = "The registered device Id.",
-                    required = true)
-            @PathParam("deviceId") String deviceId,
-            @ApiParam(
-                    name = "device-type",
-                    value = "The device type, such as ios, android or windows.",
-                    required = true)
-            @PathParam("deviceType")
-            @Size(max = 45)
-                    String deviceType,
-            @ApiParam(
-                    name = "from",
-                    value = "Get stats from what time",
-                    required = true)
-            @QueryParam("from") long from,
-            @ApiParam(
-                    name = "to",
-                    value = "Get stats up to what time",
-                    required = true)
-            @QueryParam("to") long to);
-
-    @DELETE
-    @Path("alerts/{alertType}/{deviceType}/{deviceId}")
-    @ApiOperation(
-            consumes = "application/json",
-            produces = "application/json",
-            httpMethod = "DELETE",
-            value = "Deletes Geo alerts for the device",
-            notes = "",
-            response = Response.class,
-            tags = "Geo Service Management",
-            extensions = {
-                    @Extension(properties = {
-                            @ExtensionProperty(name = Constants.SCOPE, value = "perm:geo-service:alerts-manage")
-                    })
-            }
-    )
-    @ApiResponses(value = {
-            @ApiResponse(
-                    code = 200,
-                    message = "OK.",
-                    response = Response.class,
-                    responseHeaders = {
-                            @ResponseHeader(
-                                    name = "Content-Type",
-                                    description = "The content type of the body")
-                    }),
-            @ApiResponse(
-                    code = 400,
-                    message = "Bad Request. \n Invalid Device Identifiers 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 removeGeoAlerts(
-            @ApiParam(
-                    name = "deviceId",
-                    value = "The registered device Id.",
-                    required = true)
-            @PathParam("deviceId") String deviceId,
-            @ApiParam(
-                    name = "deviceType",
-                    value = "The device type, such as ios, android or windows.",
-                    required = true)
-            @PathParam("deviceType") String deviceType,
-            @ApiParam(
-                    name = "alertType",
-                    value = "The alert type, such as Within, Speed, Stationary",
-                    required = true)
-            @PathParam("alertType") String alertType,
-            @ApiParam(
-                    name = "queryName",
-                    value = "The query name.",
-                    required = true)
-            @QueryParam("queryName") String queryName);
-}
-

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

@@ -1,565 +0,0 @@
-/*
- * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
- *
- * WSO2 Inc. 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.service.impl;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.wso2.carbon.analytics.api.AnalyticsDataAPI;
-import org.wso2.carbon.analytics.api.AnalyticsDataAPIUtil;
-import org.wso2.carbon.analytics.dataservice.commons.AnalyticsDataResponse;
-import org.wso2.carbon.analytics.dataservice.commons.SearchResultEntry;
-import org.wso2.carbon.analytics.dataservice.commons.SortByField;
-import org.wso2.carbon.analytics.dataservice.commons.SortType;
-import org.wso2.carbon.analytics.datasource.commons.Record;
-import org.wso2.carbon.analytics.datasource.commons.exception.AnalyticsException;
-import org.wso2.carbon.context.CarbonContext;
-import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
-import org.wso2.carbon.device.mgt.common.DeviceManagementConstants.GeoServices;
-import org.wso2.carbon.device.mgt.common.DeviceManagementException;
-import org.wso2.carbon.device.mgt.common.authorization.DeviceAccessAuthorizationException;
-import org.wso2.carbon.device.mgt.common.geo.service.*;
-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;
-import org.wso2.carbon.device.mgt.core.util.DeviceManagerUtil;
-import org.wso2.carbon.device.mgt.jaxrs.service.api.GeoLocationBasedService;
-import org.wso2.carbon.device.mgt.jaxrs.util.Constants;
-import org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils;
-import org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtUtil;
-import org.wso2.carbon.user.api.UserStoreException;
-import org.wso2.carbon.utils.multitenancy.MultitenantUtils;
-
-import javax.ws.rs.*;
-import javax.ws.rs.core.Response;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * The api for
- */
-public class GeoLocationBasedServiceImpl implements GeoLocationBasedService {
-
-    private static Log log = LogFactory.getLog(GeoLocationBasedServiceImpl.class);
-
-    @Path("stats/{deviceType}/{deviceId}")
-    @GET
-    @Consumes("application/json")
-    @Produces("application/json")
-    public Response getGeoDeviceStats(@PathParam("deviceId") String deviceId,
-                                      @PathParam("deviceType") String deviceType,
-                                      @QueryParam("from") long from, @QueryParam("to") long to) {
-        try {
-            if (!DeviceManagerUtil.isPublishLocationResponseEnabled()) {
-                return Response.status(Response.Status.BAD_REQUEST.getStatusCode())
-                        .entity("Unable to retrive Geo Device stats. Geo Data publishing does not enabled.").build();
-            }
-        } catch (DeviceManagementException e) {
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode()).entity(e.getMessage()).build();
-        }
-        String tableName = "IOT_PER_DEVICE_STREAM_GEO_FUSEDSPATIALEVENT";
-        String fromDate = String.valueOf(from);
-        String toDate = String.valueOf(to);
-        String query = "id:" + deviceId + " AND type:" + deviceType;
-        if (from != 0 || to != 0) {
-            query += " AND timeStamp : [" + fromDate + " TO " + toDate + "]";
-        }
-        try {
-            if (!DeviceMgtAPIUtils.getDeviceAccessAuthorizationService().isUserAuthorized(
-                    new DeviceIdentifier(deviceId, deviceType),
-                    DeviceGroupConstants.Permissions.DEFAULT_STATS_MONITOR_PERMISSIONS)) {
-                return Response.status(Response.Status.UNAUTHORIZED.getStatusCode()).build();
-            }
-            List<SortByField> sortByFields = new ArrayList<>();
-            SortByField sortByField = new SortByField("timeStamp", SortType.ASC);
-            sortByFields.add(sortByField);
-
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername());
-
-            try {
-                String tenantDomain = MultitenantUtils.getTenantDomain(authorizedUser);
-                int tenantId = DeviceMgtAPIUtils.getRealmService().getTenantManager().getTenantId(tenantDomain);
-                AnalyticsDataAPI analyticsDataAPI = DeviceMgtAPIUtils.getAnalyticsDataAPI();
-                List<SearchResultEntry> searchResults = analyticsDataAPI.search(tenantId, tableName, query,
-                        0,
-                        100,
-                        sortByFields);
-                List<Event> events = getEventBeans(analyticsDataAPI, tenantId, tableName, new ArrayList<String>(),
-                        searchResults);
-                return Response.ok().entity(events).build();
-            } catch (AnalyticsException | UserStoreException e) {
-                log.error("Failed to perform search on table: " + tableName + " : " + e.getMessage(), e);
-                throw DeviceMgtUtil.buildBadRequestException(
-                        Constants.ErrorMessages.STATUS_BAD_REQUEST_MESSAGE_DEFAULT);
-            }
-        } catch (DeviceAccessAuthorizationException e) {
-            log.error(e.getErrorMessage());
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode()).build();
-        }
-    }
-
-    @Path("stats/device-locations")
-    @GET
-    @Consumes("application/json")
-    @Produces("application/json")
-    public Response getGeoDeviceLocations(
-            @QueryParam("minLat") double minLat,
-            @QueryParam("maxLat") double maxLat,
-            @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();
-        List<GeoCluster> geoClusters;
-        try {
-            geoClusters = deviceManagementService.findGeoClusters(null, southWest, northEast, geohashLength);
-        } catch (DeviceManagementException e) {
-            String msg = "Error occurred while retrieving geo clusters ";
-            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}")
-    @POST
-    @Consumes("application/json")
-    @Produces("application/json")
-    public Response createGeoAlerts(Alert alert, @PathParam("deviceId") String deviceId,
-                                    @PathParam("deviceType") String deviceType,
-                                    @PathParam("alertType") String alertType) {
-        try {
-            if (!DeviceMgtAPIUtils.getDeviceAccessAuthorizationService().isUserAuthorized(
-                    new DeviceIdentifier(deviceId, deviceType),
-                    DeviceGroupConstants.Permissions.DEFAULT_STATS_MONITOR_PERMISSIONS)) {
-                return Response.status(Response.Status.UNAUTHORIZED.getStatusCode()).build();
-            }
-
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername()
-            );
-
-            DeviceIdentifier identifier = new DeviceIdentifier();
-            identifier.setId(deviceId);
-            identifier.setType(deviceType);
-
-            GeoLocationProviderService geoService = DeviceMgtAPIUtils.getGeoService();
-            geoService.createGeoAlert(alert, identifier, alertType);
-            return Response.ok().build();
-        } catch (DeviceAccessAuthorizationException | GeoLocationBasedServiceException e) {
-            String error = "Error occurred while creating the geo alert for " + deviceType + " with id: " + deviceId;
-            log.error(error, e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
-        } catch (AlertAlreadyExistException e) {
-            String error = "A geo alert with this name already exists.";
-            log.error(error,e);
-            return Response.status(Response.Status.BAD_REQUEST).entity(error).build();
-        }
-    }
-
-
-    @Path("alerts/{alertType}")
-    @POST
-    @Consumes("application/json")
-    @Produces("application/json")
-    public Response createGeoAlertsForGeoClusters(Alert alert, @PathParam("alertType") String alertType) {
-        try {
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername()
-            );
-
-            GeoLocationProviderService geoService = DeviceMgtAPIUtils.getGeoService();
-            geoService.createGeoAlert(alert, alertType);
-            return Response.ok().build();
-        } catch (GeoLocationBasedServiceException e) {
-            String error = "Error occurred while creating " + alertType + " alert";
-            log.error(error, e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
-        } catch (AlertAlreadyExistException e) {
-            String error = "A geo alert with this name already exists.";
-            log.error(error,e);
-            return Response.status(Response.Status.BAD_REQUEST).entity(error).build();
-        }
-    }
-
-
-    @Path("alerts/{alertType}/{deviceType}/{deviceId}")
-    @PUT
-    @Consumes("application/json")
-    @Produces("application/json")
-    public Response updateGeoAlerts(Alert alert, @PathParam("deviceId") String deviceId,
-                                    @PathParam("deviceType") String deviceType,
-                                    @PathParam("alertType") String alertType) {
-        try {
-            if (!DeviceMgtAPIUtils.getDeviceAccessAuthorizationService().isUserAuthorized(
-                    new DeviceIdentifier(deviceId, deviceType),
-                    DeviceGroupConstants.Permissions.DEFAULT_STATS_MONITOR_PERMISSIONS)) {
-                return Response.status(Response.Status.UNAUTHORIZED.getStatusCode()).build();
-            }
-
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername()
-            );
-
-            DeviceIdentifier identifier = new DeviceIdentifier();
-            identifier.setId(deviceId);
-            identifier.setType(deviceType);
-
-            GeoLocationProviderService geoService = DeviceMgtAPIUtils.getGeoService();
-            geoService.updateGeoAlert(alert, identifier, alertType);
-            return Response.ok().build();
-        } catch (DeviceAccessAuthorizationException | GeoLocationBasedServiceException e) {
-            String error = "Error occurred while creating the geo alert for " + deviceType + " with id: " + deviceId;
-            log.error(error, e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
-        } catch (AlertAlreadyExistException e) {
-            String error = "A geo alert with this name already exists.";
-            log.error(error,e);
-            return Response.status(Response.Status.BAD_REQUEST).entity(error).build();
-        }
-    }
-
-    @Path("alerts/{alertType}")
-    @PUT
-    @Consumes("application/json")
-    @Produces("application/json")
-    public Response updateGeoAlertsForGeoClusters(Alert alert, @PathParam("alertType") String alertType) {
-        try {
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername()
-            );
-
-            GeoLocationProviderService geoService = DeviceMgtAPIUtils.getGeoService();
-            geoService.updateGeoAlert(alert, alertType);
-            return Response.ok().build();
-        } catch (GeoLocationBasedServiceException e) {
-            String error = "Error occurred while updating the geo alert for geo clusters";
-            log.error(error, e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
-        } catch (AlertAlreadyExistException e) {
-            String error = "A geo alert with this name already exists.";
-            log.error(error,e);
-            return Response.status(Response.Status.BAD_REQUEST).entity(error).build();
-        }
-    }
-
-    @Path("alerts/{alertType}/{deviceType}/{deviceId}")
-    @DELETE
-    @Consumes("application/json")
-    @Produces("application/json")
-    public Response removeGeoAlerts(@PathParam("deviceId") String deviceId,
-                                    @PathParam("deviceType") String deviceType,
-                                    @PathParam("alertType") String alertType,
-                                    @QueryParam("queryName") String queryName) {
-        try {
-            if (!DeviceMgtAPIUtils.getDeviceAccessAuthorizationService().isUserAuthorized(
-                    new DeviceIdentifier(deviceId, deviceType),
-                    DeviceGroupConstants.Permissions.DEFAULT_STATS_MONITOR_PERMISSIONS)) {
-                return Response.status(Response.Status.UNAUTHORIZED.getStatusCode()).build();
-            }
-
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername()
-            );
-
-            DeviceIdentifier identifier = new DeviceIdentifier();
-            identifier.setId(deviceId);
-            identifier.setType(deviceType);
-
-            GeoLocationProviderService geoService = DeviceMgtAPIUtils.getGeoService();
-            geoService.removeGeoAlert(alertType, identifier, queryName);
-            return Response.ok().build();
-        } catch (DeviceAccessAuthorizationException | GeoLocationBasedServiceException e) {
-            String error = "Error occurred while removing the geo alert for " + deviceType + " with id: " + deviceId;
-            log.error(error, e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
-        }
-    }
-
-    @Path("alerts/{alertType}")
-    @DELETE
-    @Consumes("application/json")
-    @Produces("application/json")
-    public Response removeGeoAlertsForGeoClusters(@PathParam("alertType") String alertType, @QueryParam("queryName") String queryName) {
-        try {
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername()
-            );
-
-            GeoLocationProviderService geoService = DeviceMgtAPIUtils.getGeoService();
-            geoService.removeGeoAlert(alertType, queryName);
-            return Response.ok().build();
-        } catch (GeoLocationBasedServiceException e) {
-            String error = "Error occurred while removing the geo alert for geo clusters";
-            log.error(error, e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
-        }
-    }
-
-    @Path("alerts/{alertType}/{deviceType}/{deviceId}")
-    @GET
-    @Consumes("application/json")
-    @Produces("application/json")
-    public Response getGeoAlerts(@PathParam("deviceId") String deviceId,
-                                 @PathParam("deviceType") String deviceType,
-                                 @PathParam("alertType") String alertType) {
-        try {
-            if (!DeviceMgtAPIUtils.getDeviceAccessAuthorizationService().isUserAuthorized(
-                    new DeviceIdentifier(deviceId, deviceType),
-                    DeviceGroupConstants.Permissions.DEFAULT_STATS_MONITOR_PERMISSIONS)) {
-                return Response.status(Response.Status.UNAUTHORIZED.getStatusCode()).build();
-            }
-
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername()
-            );
-
-            DeviceIdentifier identifier = new DeviceIdentifier();
-            identifier.setId(deviceId);
-            identifier.setType(deviceType);
-
-            GeoLocationProviderService geoService = DeviceMgtAPIUtils.getGeoService();
-
-            if (GeoServices.ALERT_TYPE_WITHIN.equals(alertType)) {
-                List<GeoFence> alerts = geoService.getWithinAlerts(identifier);
-                return Response.ok().entity(alerts).build();
-            } else if (GeoServices.ALERT_TYPE_EXIT.equals(alertType)) {
-                List<GeoFence> alerts = geoService.getExitAlerts(identifier);
-                return Response.ok().entity(alerts).build();
-            } else if (GeoServices.ALERT_TYPE_SPEED.equals(alertType)) {
-                String result = geoService.getSpeedAlerts(identifier);
-                return Response.ok().entity(result).build();
-            } else if (GeoServices.ALERT_TYPE_PROXIMITY.equals(alertType)) {
-                String result = geoService.getProximityAlerts(identifier);
-                return Response.ok().entity(result).build();
-            } else if (GeoServices.ALERT_TYPE_STATIONARY.equals(alertType)) {
-                List<GeoFence> alerts = geoService.getStationaryAlerts(identifier);
-                return Response.ok().entity(alerts).build();
-            } else if (GeoServices.ALERT_TYPE_TRAFFIC.equals(alertType)) {
-                List<GeoFence> alerts = geoService.getTrafficAlerts(identifier);
-                return Response.ok().entity(alerts).build();
-            }
-            return null;
-        } catch (DeviceAccessAuthorizationException | GeoLocationBasedServiceException e) {
-            String error = "Error occurred while getting the geo alerts for " + deviceType + " with id: " + deviceId;
-            log.error(error, e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
-        }
-    }
-
-    @Path("alerts/{alertType}")
-    @GET
-    @Consumes("application/json")
-    @Produces("application/json")
-    public Response getGeoAlertsForGeoClusters(@PathParam("alertType") String alertType) {
-        try {
-
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername()
-            );
-
-            GeoLocationProviderService geoService = DeviceMgtAPIUtils.getGeoService();
-
-            if (GeoServices.ALERT_TYPE_WITHIN.equals(alertType)) {
-                List<GeoFence> alerts = geoService.getWithinAlerts();
-                return Response.ok().entity(alerts).build();
-            } else if (GeoServices.ALERT_TYPE_EXIT.equals(alertType)) {
-                List<GeoFence> alerts = geoService.getExitAlerts();
-                return Response.ok().entity(alerts).build();
-            } else if (GeoServices.ALERT_TYPE_SPEED.equals(alertType)) {
-                String result = geoService.getSpeedAlerts();
-                return Response.ok().entity(result).build();
-            } else if (GeoServices.ALERT_TYPE_PROXIMITY.equals(alertType)) {
-                String result = geoService.getProximityAlerts();
-                return Response.ok().entity(result).build();
-            } else if (GeoServices.ALERT_TYPE_STATIONARY.equals(alertType)) {
-                List<GeoFence> alerts = geoService.getStationaryAlerts();
-                return Response.ok().entity(alerts).build();
-            } else if (GeoServices.ALERT_TYPE_TRAFFIC.equals(alertType)) {
-                List<GeoFence> alerts = geoService.getTrafficAlerts();
-                return Response.ok().entity(alerts).build();
-            }
-            return null;
-        } catch (GeoLocationBasedServiceException e) {
-            String error = "Error occurred while getting the geo alerts for " + alertType + " alert";
-            log.error(error, e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(error).build();
-        }
-    }
-
-    @Path("alerts/history/{deviceType}/{deviceId}")
-    @GET
-    @Consumes("application/json")
-    @Produces("application/json")
-    public Response getGeoAlertsHistory(@PathParam("deviceId") String deviceId,
-                                        @PathParam("deviceType") String deviceType,
-                                        @QueryParam("from") long from, @QueryParam("to") long to) {
-        String tableName = "IOT_PER_DEVICE_STREAM_GEO_ALERTNOTIFICATIONS";
-        String fromDate = String.valueOf(from);
-        String toDate = String.valueOf(to);
-        String query = "id:" + deviceId + " AND type:" + deviceType;
-        if (from != 0 || to != 0) {
-            query += " AND timeStamp : [" + fromDate + " TO " + toDate + "]";
-        }
-        try {
-            if (!DeviceMgtAPIUtils.getDeviceAccessAuthorizationService().isUserAuthorized(
-                    new DeviceIdentifier(deviceId, deviceType),
-                    DeviceGroupConstants.Permissions.DEFAULT_STATS_MONITOR_PERMISSIONS)) {
-                return Response.status(Response.Status.UNAUTHORIZED.getStatusCode()).build();
-            }
-            List<SortByField> sortByFields = new ArrayList<>();
-            SortByField sortByField = new SortByField("timeStamp", SortType.ASC);
-            sortByFields.add(sortByField);
-
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername());
-
-            try {
-                String tenantDomain = MultitenantUtils.getTenantDomain(authorizedUser);
-                int tenantId = DeviceMgtAPIUtils.getRealmService().getTenantManager().getTenantId(tenantDomain);
-                AnalyticsDataAPI analyticsDataAPI = DeviceMgtAPIUtils.getAnalyticsDataAPI();
-                List<SearchResultEntry> searchResults = analyticsDataAPI.search(tenantId, tableName, query,
-                        0,
-                        100,
-                        sortByFields);
-                List<Event> events = getEventBeans(analyticsDataAPI, tenantId, tableName, new ArrayList<String>(),
-                        searchResults);
-                return Response.ok().entity(events).build();
-            } catch (AnalyticsException | UserStoreException e) {
-                log.error("Failed to perform search on table: " + tableName + " : " + e.getMessage(), e);
-                throw DeviceMgtUtil.buildBadRequestException(
-                        Constants.ErrorMessages.STATUS_BAD_REQUEST_MESSAGE_DEFAULT);
-            }
-        } catch (DeviceAccessAuthorizationException e) {
-            log.error(e.getErrorMessage());
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode()).build();
-        }
-    }
-
-    @Path("alerts/history")
-    @GET
-    @Consumes("application/json")
-    @Produces("application/json")
-    public Response getGeoAlertsHistoryForGeoClusters(@QueryParam("from") long from, @QueryParam("to") long to) {
-        String tableName = "IOT_PER_DEVICE_STREAM_GEO_ALERTNOTIFICATIONS";
-        String fromDate = String.valueOf(from);
-        String toDate = String.valueOf(to);
-        String query = "";
-        if (from != 0 || to != 0) {
-            query = "timeStamp : [" + fromDate + " TO " + toDate + "]";
-        }
-        try {
-            List<SortByField> sortByFields = new ArrayList<>();
-            SortByField sortByField = new SortByField("timeStamp", SortType.ASC);
-            sortByFields.add(sortByField);
-
-            // this is the user who initiates the request
-            String authorizedUser = MultitenantUtils.getTenantAwareUsername(
-                    CarbonContext.getThreadLocalCarbonContext().getUsername());
-
-            try {
-                String tenantDomain = MultitenantUtils.getTenantDomain(authorizedUser);
-                int tenantId = DeviceMgtAPIUtils.getRealmService().getTenantManager().getTenantId(tenantDomain);
-                AnalyticsDataAPI analyticsDataAPI = DeviceMgtAPIUtils.getAnalyticsDataAPI();
-                List<SearchResultEntry> searchResults = analyticsDataAPI.search(tenantId, tableName, query,
-                        0,
-                        100,
-                        sortByFields);
-                List<Event> events = getEventBeans(analyticsDataAPI, tenantId, tableName, new ArrayList<String>(),
-                        searchResults);
-                return Response.ok().entity(events).build();
-            } catch (AnalyticsException | UserStoreException e) {
-                log.error("Failed to perform search on table: " + tableName + " : " + e.getMessage(), e);
-                throw DeviceMgtUtil.buildBadRequestException(
-                        Constants.ErrorMessages.STATUS_BAD_REQUEST_MESSAGE_DEFAULT);
-            }
-        } catch (Exception e) {
-            log.error(e.getMessage());
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode()).build();
-        }
-    }
-
-    private List<Event> getEventBeans(AnalyticsDataAPI analyticsDataAPI, int tenantId, String tableName,
-                                      List<String> columns,
-                                      List<SearchResultEntry> searchResults) throws AnalyticsException {
-        List<String> ids = getIds(searchResults);
-        List<String> requiredColumns = (columns == null || columns.isEmpty()) ? null : columns;
-        AnalyticsDataResponse response = analyticsDataAPI.get(tenantId, tableName, 1, requiredColumns, ids);
-        List<Record> records = AnalyticsDataAPIUtil.listRecords(analyticsDataAPI, response);
-        Map<String, Event> eventBeanMap = getEventBeanKeyedWithIds(records);
-        return getSortedEventBeans(eventBeanMap, searchResults);
-    }
-
-    private List<Event> getSortedEventBeans(Map<String, Event> eventBeanMap,
-                                            List<SearchResultEntry> searchResults) {
-        List<Event> sortedRecords = new ArrayList<>();
-        for (SearchResultEntry entry : searchResults) {
-            sortedRecords.add(eventBeanMap.get(entry.getId()));
-        }
-        return sortedRecords;
-    }
-
-    private Map<String, Event> getEventBeanKeyedWithIds(List<Record> records) {
-        Map<String, Event> eventBeanMap = new HashMap<>();
-        for (Record record : records) {
-            Event event = getEventBean(record);
-            eventBeanMap.put(event.getId(), event);
-        }
-        return eventBeanMap;
-    }
-
-    private List<String> getIds(List<SearchResultEntry> searchResults) {
-        List<String> ids = new ArrayList<>();
-        if (searchResults != null) {
-            for (SearchResultEntry resultEntry : searchResults) {
-                ids.add(resultEntry.getId());
-            }
-        }
-        return ids;
-    }
-
-    private static Event getEventBean(Record record) {
-        Event eventBean = new Event();
-        eventBean.setId(record.getId());
-        eventBean.setTableName(record.getTableName());
-        eventBean.setTimestamp(record.getTimestamp());
-        eventBean.setValues(record.getValues());
-        return eventBean;
-    }
-}

components/device-mgt/org.wso2.carbon.device.mgt.v09.api/src/main/webapp/WEB-INF/cxf-servlet.xml

@@ -37,7 +37,6 @@
             <ref bean="userManagementService"/>
             <ref bean="userManagementAdminService"/>
             <ref bean="groupManagementService"/>
-            <ref bean="geoService"/>
             <ref bean="remoteSessionService"/>
             <ref bean="groupManagementAdminService"/>
             <ref bean="applicationManagementAdminService"/>
@@ -81,7 +80,6 @@
     <bean id="roleManagementService" class="org.wso2.carbon.device.mgt.jaxrs.service.impl.RoleManagementServiceImpl"/>
     <bean id="userManagementService" class="org.wso2.carbon.device.mgt.jaxrs.service.impl.UserManagementServiceImpl"/>
     <bean id="groupManagementService" class="org.wso2.carbon.device.mgt.jaxrs.service.impl.GroupManagementServiceImpl"/>
-    <bean id="geoService" class="org.wso2.carbon.device.mgt.jaxrs.service.impl.GeoLocationBasedServiceImpl"/>
     <bean id="remoteSessionService" class="org.wso2.carbon.device.mgt.jaxrs.service.impl.RemoteSessionServiceImpl"/>
     <bean id="deviceManagementAdminService" class="org.wso2.carbon.device.mgt.jaxrs.service.impl.admin.DeviceManagementAdminServiceImpl"/>
     <bean id="applicationManagementAdminService" class="org.wso2.carbon.device.mgt.jaxrs.service.impl.admin.ApplicationManagementAdminServiceImpl"/>

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

@@ -1,78 +0,0 @@
-/*
- *   Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
- *
- *   WSO2 Inc. 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.service.impl;
-
-import org.mockito.Mockito;
-import org.testng.Assert;
-import org.testng.annotations.BeforeClass;
-import org.testng.annotations.Test;
-import org.wso2.carbon.context.PrivilegedCarbonContext;
-import org.wso2.carbon.device.mgt.common.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.core.service.DeviceManagementProviderService;
-import org.wso2.carbon.device.mgt.jaxrs.service.api.GeoLocationBasedService;
-
-import javax.ws.rs.core.Response;
-import java.util.ArrayList;
-import java.util.List;
-
-public class GeoLocationBasedServiceImplTest {
-    private DeviceManagementProviderService deviceManagementProviderService;
-    private PrivilegedCarbonContext context;
-    private GeoLocationBasedService geoLocationBasedService;
-
-    @BeforeClass
-    public void init() {
-        deviceManagementProviderService = Mockito.mock(DeviceManagementProviderService.class);
-        geoLocationBasedService = new GeoLocationBasedServiceImpl();
-        context = Mockito.mock(PrivilegedCarbonContext.class);
-        Mockito.doReturn("admin").when(context).getUsername();
-    }
-
-    @Test(description = "This method tests the behaviour of getGeoDeviceLocations when there are no devices" +
-            "in the given map boundaries")
-    public void testGetGeoDeviceLocations1() throws DeviceManagementException {
-        Mockito.doReturn(new ArrayList<GeoCluster>()).when(deviceManagementProviderService)
-                .findGeoClusters(null, Mockito.any(GeoCoordinate.class), Mockito.any(GeoCoordinate.class), Mockito.anyInt());
-        Response response = geoLocationBasedService.getGeoDeviceLocations(0.4, 15, 75.6,
-                90.1, 6);
-        Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
-                "getGeoDeviceLocations request failed with valid parameters");
-    }
-
-    @Test(description = "This method tests the behaviour of getGeoDeviceLocations when there are devices" +
-            "in the given map boundaries")
-    public void testGetGeoDeviceLocations2() throws DeviceManagementException {
-        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", "android", "1234"));
-        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", "android", "1234"));
-        Mockito.doReturn(geoClusters).when(deviceManagementProviderService)
-                .findGeoClusters(null,Mockito.any(GeoCoordinate.class), Mockito.any(GeoCoordinate.class), Mockito.anyInt());
-        Response response = geoLocationBasedService.getGeoDeviceLocations(0.4, 15, 75.6,
-                90.1, 6);
-        Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
-                "getGeoDeviceLocations request failed with valid parameters");
-    }
-}