Merge branch 'master' of https://github.com/wso2/carbon-device-mgt

components/device-mgt/org.wso2.carbon.device.mgt.analytics.dashboard/pom.xml

@@ -64,7 +64,8 @@
                         </Private-Package>
                         <Export-Package>
                             org.wso2.carbon.device.mgt.analytics.dashboard,
-                            org.wso2.carbon.device.mgt.analytics.dashboard.dao.exception
+                            org.wso2.carbon.device.mgt.analytics.dashboard.dao.exception,
+                            org.wso2.carbon.device.mgt.analytics.dashboard.dao.bean
                         </Export-Package>
                         <Import-Package>
                             org.osgi.framework,

components/device-mgt/org.wso2.carbon.device.mgt.analytics.dashboard/src/main/java/org/wso2/carbon/device/mgt/analytics/dashboard/GadgetDataService.java

@@ -18,12 +18,12 @@
 
 package org.wso2.carbon.device.mgt.analytics.dashboard;
 
-import org.wso2.carbon.device.mgt.analytics.dashboard.dao.exception.InvalidParameterException;
+import org.wso2.carbon.device.mgt.analytics.dashboard.dao.bean.*;
+import org.wso2.carbon.device.mgt.analytics.dashboard.dao.exception.InvalidParameterValueException;
 import org.wso2.carbon.device.mgt.common.PaginationResult;
 
 import java.sql.SQLException;
 import java.util.List;
-import java.util.Map;
 
 /**
  * To be updated...
@@ -31,62 +31,56 @@ import java.util.Map;
 public interface GadgetDataService {
 
     @SuppressWarnings("unused")
-    int getTotalDeviceCount() throws SQLException;
+    DeviceCountByGroupEntry getDeviceCount(FilterSet filterSet) throws InvalidParameterValueException, SQLException;
 
     @SuppressWarnings("unused")
-    int getActiveDeviceCount() throws SQLException;
+    DeviceCountByGroupEntry getFeatureNonCompliantDeviceCount(String nonCompliantFeatureCode,
+                                           FilterSet filterSet) throws InvalidParameterValueException, SQLException;
 
     @SuppressWarnings("unused")
-    int getInactiveDeviceCount() throws SQLException;
+    DeviceCountByGroupEntry getTotalDeviceCount() throws SQLException;
 
     @SuppressWarnings("unused")
-    int getRemovedDeviceCount() throws SQLException;
+    List<DeviceCountByGroupEntry> getDeviceCountsByConnectivityStatuses() throws SQLException;
 
     @SuppressWarnings("unused")
-    int getNonCompliantDeviceCount() throws SQLException;
+    List<DeviceCountByGroupEntry> getDeviceCountsByPotentialVulnerabilities() throws SQLException;
-
-    @SuppressWarnings("unused")
-    int getUnmonitoredDeviceCount() throws SQLException;
 
     @SuppressWarnings("unused")
     PaginationResult getNonCompliantDeviceCountsByFeatures(int startIndex, int resultCount)
-                                                           throws InvalidParameterException, SQLException;
+                                                           throws InvalidParameterValueException, SQLException;
 
     @SuppressWarnings("unused")
-    int getDeviceCount(Map<String, Object> filters) throws SQLException;
+    List<DeviceCountByGroupEntry> getDeviceCountsByPlatforms(FilterSet filterSet)
+                                          throws InvalidParameterValueException, SQLException;
 
     @SuppressWarnings("unused")
-    int getFeatureNonCompliantDeviceCount(String nonCompliantFeatureCode,
+    List<DeviceCountByGroupEntry> getFeatureNonCompliantDeviceCountsByPlatforms(String nonCompliantFeatureCode,
-                                          Map<String, Object> filters) throws InvalidParameterException, SQLException;
+                                          FilterSet filterSet) throws InvalidParameterValueException, SQLException;
 
     @SuppressWarnings("unused")
-    Map<String, Integer> getDeviceCountsByPlatforms(Map<String, Object> filters) throws SQLException;
+    List<DeviceCountByGroupEntry> getDeviceCountsByOwnershipTypes(FilterSet filterSet)
+                                          throws InvalidParameterValueException, SQLException;
 
     @SuppressWarnings("unused")
-    Map<String, Integer> getFeatureNonCompliantDeviceCountsByPlatforms(String nonCompliantFeatureCode,
+    List<DeviceCountByGroupEntry> getFeatureNonCompliantDeviceCountsByOwnershipTypes(String nonCompliantFeatureCode,
-                                          Map<String, Object> filters) throws InvalidParameterException, SQLException;
+                                          FilterSet filterSet) throws InvalidParameterValueException, SQLException;
 
     @SuppressWarnings("unused")
-    Map<String, Integer> getDeviceCountsByOwnershipTypes(Map<String, Object> filters) throws SQLException;
+    PaginationResult getDevicesWithDetails(FilterSet filterSet, int startIndex, int resultCount)
-
+                                                   throws InvalidParameterValueException, SQLException;
-    @SuppressWarnings("unused")
-    Map<String, Integer> getFeatureNonCompliantDeviceCountsByOwnershipTypes(String nonCompliantFeatureCode,
-                                          Map<String, Object> filters) throws InvalidParameterException, SQLException;
-
-    @SuppressWarnings("unused")
-    PaginationResult getDevicesWithDetails(Map<String, Object> filters,
-                                      int startIndex, int resultCount) throws InvalidParameterException, SQLException;
 
     @SuppressWarnings("unused")
     PaginationResult getFeatureNonCompliantDevicesWithDetails(String nonCompliantFeatureCode,
-                                       Map<String, Object> filters, int startIndex, int resultCount)
+                                                   FilterSet filterSet, int startIndex, int resultCount)
-                                                            throws InvalidParameterException, SQLException;
+                                                               throws InvalidParameterValueException, SQLException;
 
     @SuppressWarnings("unused")
-    List<Map<String, Object>> getDevicesWithDetails(Map<String, Object> filters) throws SQLException;
+    List<DetailedDeviceEntry> getDevicesWithDetails(FilterSet filterSet)
+                                                    throws InvalidParameterValueException, SQLException;
 
     @SuppressWarnings("unused")
-    List<Map<String, Object>> getFeatureNonCompliantDevicesWithDetails(String nonCompliantFeatureCode,
+    List<DetailedDeviceEntry> getFeatureNonCompliantDevicesWithDetails(String nonCompliantFeatureCode,
-                                          Map<String, Object> filters) throws InvalidParameterException, SQLException;
+                                          FilterSet filterSet) throws InvalidParameterValueException, SQLException;
 
 }

components/device-mgt/org.wso2.carbon.device.mgt.analytics.dashboard/src/main/java/org/wso2/carbon/device/mgt/analytics/dashboard/dao/GadgetDataServiceDAO.java

@@ -18,85 +18,56 @@
 
 package org.wso2.carbon.device.mgt.analytics.dashboard.dao;
 
-import org.wso2.carbon.device.mgt.analytics.dashboard.dao.exception.InvalidParameterException;
+import org.wso2.carbon.device.mgt.analytics.dashboard.dao.bean.*;
+import org.wso2.carbon.device.mgt.analytics.dashboard.dao.exception.InvalidParameterValueException;
 import org.wso2.carbon.device.mgt.common.PaginationResult;
 
 import java.sql.SQLException;
 import java.util.List;
-import java.util.Map;
 
 public interface GadgetDataServiceDAO {
 
-    /**
+    DeviceCountByGroupEntry getDeviceCount(FilterSet filterSet) throws InvalidParameterValueException, SQLException;
-     * Method to get total filtered device count from a particular tenant.
+
-     *
+    DeviceCountByGroupEntry getFeatureNonCompliantDeviceCount(String nonCompliantFeatureCode,
-     * @return Total filtered device count.
+                                           FilterSet filterSet) throws InvalidParameterValueException, SQLException;
-     */
-    int getTotalDeviceCount() throws SQLException;
 
     /**
-     * Method to get active device count from a particular tenant.
+     * Method to get total device count from a particular tenant.
      *
-     * @return active device count.
+     * @return Total device count.
      */
-    int getActiveDeviceCount() throws SQLException;
+    DeviceCountByGroupEntry getTotalDeviceCount() throws SQLException;
 
-    /**
+    List<DeviceCountByGroupEntry> getDeviceCountsByConnectivityStatuses() throws SQLException;
-     * Method to get inactive device count from a particular tenant.
-     *
-     * @return inactive device count.
-     */
-    int getInactiveDeviceCount() throws SQLException;
 
-    /**
+    List<DeviceCountByGroupEntry> getDeviceCountsByPotentialVulnerabilities() throws SQLException;
-     * Method to get removed device count from a particular tenant.
-     *
-     * @return removed device count.
-     */
-    int getRemovedDeviceCount() throws SQLException;
-
-    /**
-     * Method to get non-compliant device count from a particular tenant.
-     *
-     * @return Non-compliant device count.
-     */
-    int getNonCompliantDeviceCount() throws SQLException;
-
-    /**
-     * Method to get unmonitored device count from a particular tenant.
-     *
-     * @return Unmonitored device count.
-     */
-    int getUnmonitoredDeviceCount() throws SQLException;
 
     PaginationResult getNonCompliantDeviceCountsByFeatures(int startIndex, int resultCount)
-            throws InvalidParameterException, SQLException;
+                                          throws InvalidParameterValueException, SQLException;
 
-    int getDeviceCount(Map<String, Object> filters) throws SQLException;
+    List<DeviceCountByGroupEntry> getDeviceCountsByPlatforms(FilterSet filterSet)
+                                          throws InvalidParameterValueException, SQLException;
 
-    int getFeatureNonCompliantDeviceCount(String nonCompliantFeatureCode,
+    List<DeviceCountByGroupEntry> getFeatureNonCompliantDeviceCountsByPlatforms(String nonCompliantFeatureCode,
-                                          Map<String, Object> filters) throws InvalidParameterException, SQLException;
+                                          FilterSet filterSet) throws InvalidParameterValueException, SQLException;
 
-    Map<String, Integer> getDeviceCountsByPlatforms(Map<String, Object> filters) throws SQLException;
+    List<DeviceCountByGroupEntry> getDeviceCountsByOwnershipTypes(FilterSet filterSet)
+                                          throws InvalidParameterValueException, SQLException;
 
-    Map<String, Integer> getFeatureNonCompliantDeviceCountsByPlatforms(String nonCompliantFeatureCode,
+    List<DeviceCountByGroupEntry> getFeatureNonCompliantDeviceCountsByOwnershipTypes(String nonCompliantFeatureCode,
-                                          Map<String, Object> filters) throws InvalidParameterException, SQLException;
+                                          FilterSet filterSet) throws InvalidParameterValueException, SQLException;
 
-    Map<String, Integer> getDeviceCountsByOwnershipTypes(Map<String, Object> filters) throws SQLException;
+    PaginationResult getDevicesWithDetails(FilterSet filterSet, int startIndex, int resultCount)
-
+                                          throws InvalidParameterValueException, SQLException;
-    Map<String, Integer> getFeatureNonCompliantDeviceCountsByOwnershipTypes(String nonCompliantFeatureCode,
-                                          Map<String, Object> filters) throws InvalidParameterException, SQLException;
-
-    PaginationResult getDevicesWithDetails(Map<String, Object> filters,
-                                      int startIndex, int resultCount) throws InvalidParameterException, SQLException;
 
     PaginationResult getFeatureNonCompliantDevicesWithDetails(String nonCompliantFeatureCode,
-                                    Map<String, Object> filters, int startIndex, int resultCount)
+         FilterSet filterSet, int startIndex, int resultCount) throws InvalidParameterValueException, SQLException;
-                                            throws InvalidParameterException, SQLException;
 
-    List<Map<String, Object>> getDevicesWithDetails(Map<String, Object> filters) throws SQLException;
+    List<DetailedDeviceEntry> getDevicesWithDetails(FilterSet filterSet)
+                                          throws InvalidParameterValueException, SQLException;
 
-    List<Map<String, Object>> getFeatureNonCompliantDevicesWithDetails(String nonCompliantFeatureCode,
+    List<DetailedDeviceEntry> getFeatureNonCompliantDevicesWithDetails(String nonCompliantFeatureCode,
-                                          Map<String, Object> filters) throws InvalidParameterException, SQLException;
+                                          FilterSet filterSet) throws InvalidParameterValueException, SQLException;
 
 }

components/device-mgt/org.wso2.carbon.device.mgt.analytics.dashboard/src/main/java/org/wso2/carbon/device/mgt/analytics/dashboard/dao/bean/DetailedDeviceEntry.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2016, 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.analytics.dashboard.dao.bean;
+
+public class DetailedDeviceEntry {
+
+    private int deviceId;
+    private String platform;
+    private String ownershipType;
+    private String connectivityStatus;
+
+    @SuppressWarnings("unused")
+    public int getDeviceId() {
+        return deviceId;
+    }
+
+    public void setDeviceId(int deviceId) {
+        this.deviceId = deviceId;
+    }
+
+    @SuppressWarnings("unused")
+    public String getPlatform() {
+        return platform;
+    }
+
+    public void setPlatform(String platform) {
+        this.platform = platform;
+    }
+
+    @SuppressWarnings("unused")
+    public String getOwnershipType() {
+        return ownershipType;
+    }
+
+    public void setOwnershipType(String ownershipType) {
+        this.ownershipType = ownershipType;
+    }
+
+    @SuppressWarnings("unused")
+    public String getConnectivityStatus() {
+        return connectivityStatus;
+    }
+
+    public void setConnectivityStatus(String connectivityStatus) {
+        this.connectivityStatus = connectivityStatus;
+    }
+
+}

components/device-mgt/org.wso2.carbon.device.mgt.analytics.dashboard/src/main/java/org/wso2/carbon/device/mgt/analytics/dashboard/dao/bean/DeviceCountByGroupEntry.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2016, 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.analytics.dashboard.dao.bean;
+
+public class DeviceCountByGroupEntry {
+
+    private String group;
+    private String displayNameForGroup;
+    private int deviceCount;
+
+    @SuppressWarnings("unused")
+    public String getGroup() {
+        return group;
+    }
+
+    public void setGroup(String group) {
+        this.group = group;
+    }
+
+    @SuppressWarnings("unused")
+    public String getDisplayNameForGroup() {
+        return displayNameForGroup;
+    }
+
+    public void setDisplayNameForGroup(String displayNameForGroup) {
+        this.displayNameForGroup = displayNameForGroup;
+    }
+
+    @SuppressWarnings("unused")
+    public int getDeviceCount() {
+        return deviceCount;
+    }
+
+    public void setDeviceCount(int deviceCount) {
+        this.deviceCount = deviceCount;
+    }
+}

components/device-mgt/org.wso2.carbon.device.mgt.analytics.dashboard/src/main/java/org/wso2/carbon/device/mgt/analytics/dashboard/dao/bean/FilterSet.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2016, 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.analytics.dashboard.dao.bean;
+
+public class FilterSet {
+
+    private String connectivityStatus;
+    private String potentialVulnerability;
+    private String platform;
+    private String ownership;
+
+    public String getConnectivityStatus() {
+        return connectivityStatus;
+    }
+
+    public void setConnectivityStatus(String connectivityStatus) {
+        this.connectivityStatus = connectivityStatus;
+    }
+
+    public String getPotentialVulnerability() {
+        return potentialVulnerability;
+    }
+
+    public void setPotentialVulnerability(String potentialVulnerability) {
+        this.potentialVulnerability = potentialVulnerability;
+    }
+
+    public String getPlatform() {
+        return platform;
+    }
+
+    @SuppressWarnings("unused")
+    public void setPlatform(String platform) {
+        this.platform = platform;
+    }
+
+    public String getOwnership() {
+        return ownership;
+    }
+
+    @SuppressWarnings("unused")
+    public void setOwnership(String ownership) {
+        this.ownership = ownership;
+    }
+
+}

components/device-mgt/org.wso2.carbon.device.mgt.analytics.dashboard/src/main/java/org/wso2/carbon/device/mgt/analytics/dashboard/dao/exception/InvalidParameterValueException.java

@@ -22,7 +22,7 @@ package org.wso2.carbon.device.mgt.analytics.dashboard.dao.exception;
  * Custom exception class for catching invalid parameter issues,
  * relevant to Gadget Data Service DAO layer.
  */
-public class InvalidParameterException extends Exception {
+public class InvalidParameterValueException extends Exception {
 
     private String errorMessage;
     private static final long serialVersionUID = 2021891706072918864L;
@@ -34,7 +34,7 @@ public class InvalidParameterException extends Exception {
      * @param nestedException Nested exception.
      */
     @SuppressWarnings("unused")
-    public InvalidParameterException(String errorMessage, Exception nestedException) {
+    public InvalidParameterValueException(String errorMessage, Exception nestedException) {
         super(errorMessage, nestedException);
         setErrorMessage(errorMessage);
     }
@@ -46,7 +46,7 @@ public class InvalidParameterException extends Exception {
      * @param cause Cause of this exception.
      */
     @SuppressWarnings("unused")
-    public InvalidParameterException(String errorMessage, Throwable cause) {
+    public InvalidParameterValueException(String errorMessage, Throwable cause) {
         super(errorMessage, cause);
         setErrorMessage(errorMessage);
     }
@@ -56,7 +56,7 @@ public class InvalidParameterException extends Exception {
      *
      * @param errorMessage Specific error message.
      */
-    public InvalidParameterException(String errorMessage) {
+    public InvalidParameterValueException(String errorMessage) {
         super(errorMessage);
         setErrorMessage(errorMessage);
     }
@@ -67,7 +67,7 @@ public class InvalidParameterException extends Exception {
      * @param cause Cause of this exception.
      */
     @SuppressWarnings("unused")
-    public InvalidParameterException(Throwable cause) {
+    public InvalidParameterValueException(Throwable cause) {
         super(cause);
     }
 

components/device-mgt/org.wso2.carbon.device.mgt.analytics.dashboard/src/main/java/org/wso2/carbon/device/mgt/analytics/dashboard/dao/impl/GadgetDataServiceDAOConstants.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2016, 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.analytics.dashboard.dao.impl;
+
+public final class GadgetDataServiceDAOConstants {
+
+    public static class PotentialVulnerability {
+
+        // These constants do not hold actual database values
+        // These are just logical values defined and used @ Gadget Data Service DAO Implementation layer
+        public static final String NON_COMPLIANT = "NON_COMPLIANT";
+        public static final String UNMONITORED = "UNMONITORED";
+
+        private PotentialVulnerability() {
+            throw new AssertionError();
+        }
+
+    }
+
+    private GadgetDataServiceDAOConstants() { throw new AssertionError(); }
+
+}

components/device-mgt/org.wso2.carbon.device.mgt.analytics.dashboard/src/main/java/org/wso2/carbon/device/mgt/analytics/dashboard/dao/impl/GadgetDataServiceDAOImpl.java

@@ -21,7 +21,8 @@ package org.wso2.carbon.device.mgt.analytics.dashboard.dao.impl;
 import org.wso2.carbon.context.PrivilegedCarbonContext;
 import org.wso2.carbon.device.mgt.analytics.dashboard.dao.GadgetDataServiceDAO;
 import org.wso2.carbon.device.mgt.analytics.dashboard.dao.GadgetDataServiceDAOFactory;
-import org.wso2.carbon.device.mgt.analytics.dashboard.dao.exception.InvalidParameterException;
+import org.wso2.carbon.device.mgt.analytics.dashboard.dao.bean.*;
+import org.wso2.carbon.device.mgt.analytics.dashboard.dao.exception.InvalidParameterValueException;
 import org.wso2.carbon.device.mgt.common.PaginationResult;
 import org.wso2.carbon.device.mgt.core.dao.util.DeviceManagementDAOUtil;
 
@@ -29,115 +30,44 @@ import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
 
 public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
 
     @Override
-    public int getTotalDeviceCount() throws SQLException {
+    public DeviceCountByGroupEntry getTotalDeviceCount() throws SQLException {
-        return this.getDeviceCount(null);
+        int totalDeviceCount;
-    }
-
-    @Override
-    public int getActiveDeviceCount() throws SQLException {
-        Map<String, Object> filters = new HashMap<>();
-        filters.put("CONNECTIVITY_STATUS", "ACTIVE");
-        return this.getDeviceCount(filters);
-    }
-
-    @Override
-    public int getInactiveDeviceCount() throws SQLException {
-        Map<String, Object> filters = new HashMap<>();
-        filters.put("CONNECTIVITY_STATUS", "INACTIVE");
-        return this.getDeviceCount(filters);
-    }
-
-    @Override
-    public int getRemovedDeviceCount() throws SQLException {
-        Map<String, Object> filters = new HashMap<>();
-        filters.put("CONNECTIVITY_STATUS", "REMOVED");
-        return this.getDeviceCount(filters);
-    }
-
-    @Override
-    public int getNonCompliantDeviceCount() throws SQLException {
-        Map<String, Object> filters = new HashMap<>();
-        filters.put("IS_COMPLIANT", 0);
-        return this.getDeviceCount(filters);
-    }
-
-    @Override
-    public int getUnmonitoredDeviceCount() throws SQLException {
-        Map<String, Object> filters = new HashMap<>();
-        filters.put("POLICY_ID", -1);
-        return this.getDeviceCount(filters);
-    }
-
-    @Override
-    public PaginationResult getNonCompliantDeviceCountsByFeatures(int startIndex, int resultCount)
-                                                                  throws InvalidParameterException, SQLException {
-
-        if (startIndex < 0) {
-            throw new InvalidParameterException("Start index (startIndex) should be " +
-                "equal to 0 or greater than that.");
-        }
-
-        if (resultCount < 5) {
-            throw new InvalidParameterException("Result count (resultCount) should be " +
-                "equal to 5 or greater than that.");
-        }
-
-        Connection con;
-        PreparedStatement stmt = null;
-        ResultSet rs = null;
-        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
-        List<Map<String, Object>> filteredNonCompliantDeviceCountsByFeatures = new ArrayList<>();
-        int totalRecordsCount = 0;
         try {
-            con = this.getConnection();
+            totalDeviceCount = this.getFilteredDeviceCount(null);
-            String sql = "SELECT FEATURE_CODE, COUNT(DEVICE_ID) AS DEVICE_COUNT FROM DEVICES_VIEW_2 " +
+        } catch (InvalidParameterValueException e) {
-                "WHERE TENANT_ID = ? GROUP BY FEATURE_CODE ORDER BY DEVICE_COUNT DESC LIMIT ?, ?";
+            throw new AssertionError(e);
-            stmt = con.prepareStatement(sql);
-            stmt.setInt(1, tenantId);
-            stmt.setInt(2, startIndex);
-            stmt.setInt(3, resultCount);
-
-            // executing query
-            rs = stmt.executeQuery();
-            // fetching query results
-            Map<String, Object> filteredNonCompliantDeviceCountByFeature;
-            while (rs.next()) {
-                filteredNonCompliantDeviceCountByFeature = new HashMap<>();
-                filteredNonCompliantDeviceCountByFeature.put("FEATURE_CODE", rs.getString("FEATURE_CODE"));
-                filteredNonCompliantDeviceCountByFeature.put("DEVICE_COUNT", rs.getInt("DEVICE_COUNT"));
-                filteredNonCompliantDeviceCountsByFeatures.add(filteredNonCompliantDeviceCountByFeature);
-            }
-            // fetching total records count
-            sql = "SELECT COUNT(FEATURE_CODE) AS NON_COMPLIANT_FEATURE_COUNT FROM " +
-                "(SELECT DISTINCT FEATURE_CODE FROM DEVICES_VIEW_2 WHERE TENANT_ID = ?)";
-
-            stmt = con.prepareStatement(sql);
-            stmt.setInt(1, tenantId);
-
-            // executing query
-            rs = stmt.executeQuery();
-            // fetching query results
-            while (rs.next()) {
-                totalRecordsCount = rs.getInt("NON_COMPLIANT_FEATURE_COUNT");
-            }
-        } finally {
-            DeviceManagementDAOUtil.cleanupResources(stmt, rs);
         }
-        PaginationResult paginationResult = new PaginationResult();
+
-        paginationResult.setData(filteredNonCompliantDeviceCountsByFeatures);
+        DeviceCountByGroupEntry deviceCountByGroupEntry = new DeviceCountByGroupEntry();
-        paginationResult.setRecordsTotal(totalRecordsCount);
+        deviceCountByGroupEntry.setGroup("total");
-        return paginationResult;
+        deviceCountByGroupEntry.setDisplayNameForGroup("Total");
+        deviceCountByGroupEntry.setDeviceCount(totalDeviceCount);
+
+        return deviceCountByGroupEntry;
     }
 
-    public int getDeviceCount(Map<String, Object> filters) throws SQLException {
+    public DeviceCountByGroupEntry getDeviceCount(FilterSet filterSet)
+                                                  throws InvalidParameterValueException, SQLException {
+
+        int filteredDeviceCount = this.getFilteredDeviceCount(filterSet);
+
+        DeviceCountByGroupEntry deviceCountByGroupEntry = new DeviceCountByGroupEntry();
+        deviceCountByGroupEntry.setGroup("non-specific");
+        deviceCountByGroupEntry.setDisplayNameForGroup("Non-specific");
+        deviceCountByGroupEntry.setDeviceCount(filteredDeviceCount);
+
+        return deviceCountByGroupEntry;
+    }
+
+    private int getFilteredDeviceCount(FilterSet filterSet) throws InvalidParameterValueException, SQLException {
+
+        Map<String, Object> filters = this.extractDatabaseFiltersFromBean(filterSet);
+
         Connection con;
         PreparedStatement stmt = null;
         ResultSet rs = null;
@@ -179,13 +109,16 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
         return filteredDeviceCount;
     }
 
-    public int getFeatureNonCompliantDeviceCount(String nonCompliantFeatureCode, Map<String, Object> filters)
+    @Override
-                                                 throws InvalidParameterException, SQLException {
+    public DeviceCountByGroupEntry getFeatureNonCompliantDeviceCount(String nonCompliantFeatureCode,
+                                             FilterSet filterSet) throws InvalidParameterValueException, SQLException {
 
         if (nonCompliantFeatureCode == null || "".equals(nonCompliantFeatureCode)) {
-            throw new InvalidParameterException("nonCompliantFeatureCode should not be either null or empty.");
+            throw new InvalidParameterValueException("Non-compliant feature code should not be either null or empty.");
         }
 
+        Map<String, Object> filters = this.extractDatabaseFiltersFromBean(filterSet);
+
         Connection con;
         PreparedStatement stmt = null;
         ResultSet rs = null;
@@ -193,7 +126,8 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
         int filteredDeviceCount = 0;
         try {
             con = this.getConnection();
-            String sql = "SELECT COUNT(DEVICE_ID) AS DEVICE_COUNT FROM DEVICES_VIEW_2 WHERE TENANT_ID = ? AND FEATURE_CODE = ?";
+            String sql = "SELECT COUNT(DEVICE_ID) AS DEVICE_COUNT FROM DEVICES_VIEW_2 " +
+                    "WHERE TENANT_ID = ? AND FEATURE_CODE = ?";
             // appending filters to support advanced filtering options
             // [1] appending filter columns
             if (filters != null && filters.size() > 0) {
@@ -225,15 +159,158 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
         } finally {
             DeviceManagementDAOUtil.cleanupResources(stmt, rs);
         }
-        return filteredDeviceCount;
+
+        DeviceCountByGroupEntry deviceCountByGroupEntry = new DeviceCountByGroupEntry();
+        deviceCountByGroupEntry.setGroup("feature-non-compliant");
+        deviceCountByGroupEntry.setDisplayNameForGroup("Feature-non-compliant");
+        deviceCountByGroupEntry.setDeviceCount(filteredDeviceCount);
+
+        return deviceCountByGroupEntry;
     }
 
-    public Map<String, Integer> getDeviceCountsByPlatforms(Map<String, Object> filters) throws SQLException {
+    @Override
+    public List<DeviceCountByGroupEntry> getDeviceCountsByConnectivityStatuses() throws SQLException {
         Connection con;
         PreparedStatement stmt = null;
         ResultSet rs = null;
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
-        Map<String, Integer> filteredDeviceCountsByPlatforms = new HashMap<>();
+        List<DeviceCountByGroupEntry> deviceCountsByConnectivityStatuses = new ArrayList<>();
+        try {
+            con = this.getConnection();
+            String sql = "SELECT CONNECTIVITY_STATUS, COUNT(DEVICE_ID) AS DEVICE_COUNT FROM DEVICES_VIEW_1 " +
+                "WHERE TENANT_ID = ? GROUP BY CONNECTIVITY_STATUS";
+            stmt = con.prepareStatement(sql);
+            // [2] appending filter column values, if exist
+            stmt.setInt(1, tenantId);
+            // executing query
+            rs = stmt.executeQuery();
+            // fetching query results
+            DeviceCountByGroupEntry deviceCountByConnectivityStatus;
+            while (rs.next()) {
+                deviceCountByConnectivityStatus = new DeviceCountByGroupEntry();
+                deviceCountByConnectivityStatus.setGroup(rs.getString("CONNECTIVITY_STATUS"));
+                deviceCountByConnectivityStatus.setDisplayNameForGroup(rs.getString("CONNECTIVITY_STATUS"));
+                deviceCountByConnectivityStatus.setDeviceCount(rs.getInt("DEVICE_COUNT"));
+                deviceCountsByConnectivityStatuses.add(deviceCountByConnectivityStatus);
+            }
+        } finally {
+            DeviceManagementDAOUtil.cleanupResources(stmt, rs);
+        }
+        return deviceCountsByConnectivityStatuses;
+    }
+
+    @Override
+    public List<DeviceCountByGroupEntry> getDeviceCountsByPotentialVulnerabilities() throws SQLException {
+        // getting non-compliant device count
+        DeviceCountByGroupEntry nonCompliantDeviceCount = new DeviceCountByGroupEntry();
+        nonCompliantDeviceCount.setGroup(GadgetDataServiceDAOConstants.PotentialVulnerability.NON_COMPLIANT);
+        nonCompliantDeviceCount.setDisplayNameForGroup("Non-compliant");
+        nonCompliantDeviceCount.setDeviceCount(getNonCompliantDeviceCount());
+
+        // getting unmonitored device count
+        DeviceCountByGroupEntry unmonitoredDeviceCount = new DeviceCountByGroupEntry();
+        unmonitoredDeviceCount.setGroup(GadgetDataServiceDAOConstants.PotentialVulnerability.UNMONITORED);
+        unmonitoredDeviceCount.setDisplayNameForGroup("Unmonitored");
+        unmonitoredDeviceCount.setDeviceCount(getUnmonitoredDeviceCount());
+
+        List<DeviceCountByGroupEntry> deviceCountsByPotentialVulnerabilities = new ArrayList<>();
+        deviceCountsByPotentialVulnerabilities.add(nonCompliantDeviceCount);
+        deviceCountsByPotentialVulnerabilities.add(unmonitoredDeviceCount);
+
+        return deviceCountsByPotentialVulnerabilities;
+    }
+
+    private int getNonCompliantDeviceCount() throws SQLException {
+        FilterSet filterSet = new FilterSet();
+        filterSet.setPotentialVulnerability(GadgetDataServiceDAOConstants.PotentialVulnerability.NON_COMPLIANT);
+        try {
+            return this.getFilteredDeviceCount(filterSet);
+        } catch (InvalidParameterValueException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    private int getUnmonitoredDeviceCount() throws SQLException {
+        FilterSet filterSet = new FilterSet();
+        filterSet.setPotentialVulnerability(GadgetDataServiceDAOConstants.PotentialVulnerability.UNMONITORED);
+        try {
+            return this.getFilteredDeviceCount(filterSet);
+        } catch (InvalidParameterValueException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    @Override
+    public PaginationResult getNonCompliantDeviceCountsByFeatures(int startIndex, int resultCount)
+                                                                  throws InvalidParameterValueException, SQLException {
+
+        if (startIndex < 0) {
+            throw new InvalidParameterValueException("Start index should be equal to 0 or greater than that.");
+        }
+
+        if (resultCount < 5) {
+            throw new InvalidParameterValueException("Result count should be equal to 5 or greater than that.");
+        }
+
+        Connection con;
+        PreparedStatement stmt = null;
+        ResultSet rs = null;
+        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
+        List<DeviceCountByGroupEntry> filteredNonCompliantDeviceCountsByFeatures = new ArrayList<>();
+        int totalRecordsCount = 0;
+        try {
+            con = this.getConnection();
+            String sql = "SELECT FEATURE_CODE, COUNT(DEVICE_ID) AS DEVICE_COUNT FROM DEVICES_VIEW_2 " +
+                "WHERE TENANT_ID = ? GROUP BY FEATURE_CODE ORDER BY DEVICE_COUNT DESC LIMIT ?, ?";
+            stmt = con.prepareStatement(sql);
+            stmt.setInt(1, tenantId);
+            stmt.setInt(2, startIndex);
+            stmt.setInt(3, resultCount);
+
+            // executing query
+            rs = stmt.executeQuery();
+            // fetching query results
+            DeviceCountByGroupEntry filteredNonCompliantDeviceCountByFeature;
+            while (rs.next()) {
+                filteredNonCompliantDeviceCountByFeature = new DeviceCountByGroupEntry();
+                filteredNonCompliantDeviceCountByFeature.setGroup(rs.getString("FEATURE_CODE"));
+                filteredNonCompliantDeviceCountByFeature.setDisplayNameForGroup(rs.getString("FEATURE_CODE"));
+                filteredNonCompliantDeviceCountByFeature.setDeviceCount(rs.getInt("DEVICE_COUNT"));
+                filteredNonCompliantDeviceCountsByFeatures.add(filteredNonCompliantDeviceCountByFeature);
+            }
+            // fetching total records count
+            sql = "SELECT COUNT(FEATURE_CODE) AS NON_COMPLIANT_FEATURE_COUNT FROM " +
+                "(SELECT DISTINCT FEATURE_CODE FROM DEVICES_VIEW_2 WHERE TENANT_ID = ?)";
+
+            stmt = con.prepareStatement(sql);
+            stmt.setInt(1, tenantId);
+
+            // executing query
+            rs = stmt.executeQuery();
+            // fetching query results
+            while (rs.next()) {
+                totalRecordsCount = rs.getInt("NON_COMPLIANT_FEATURE_COUNT");
+            }
+        } finally {
+            DeviceManagementDAOUtil.cleanupResources(stmt, rs);
+        }
+        PaginationResult paginationResult = new PaginationResult();
+        paginationResult.setData(filteredNonCompliantDeviceCountsByFeatures);
+        paginationResult.setRecordsTotal(totalRecordsCount);
+        return paginationResult;
+    }
+
+    @Override
+    public List<DeviceCountByGroupEntry> getDeviceCountsByPlatforms(FilterSet filterSet)
+                                                           throws InvalidParameterValueException, SQLException {
+
+        Map<String, Object> filters = this.extractDatabaseFiltersFromBean(filterSet);
+
+        Connection con;
+        PreparedStatement stmt = null;
+        ResultSet rs = null;
+        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
+        List<DeviceCountByGroupEntry> filteredDeviceCountsByPlatforms = new ArrayList<>();
         try {
             con = this.getConnection();
             String sql, advancedSqlFiltering = "";
@@ -263,8 +340,13 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
             // executing query
             rs = stmt.executeQuery();
             // fetching query results
+            DeviceCountByGroupEntry filteredDeviceCountByPlatform;
             while (rs.next()) {
-                filteredDeviceCountsByPlatforms.put(rs.getString("PLATFORM"), rs.getInt("DEVICE_COUNT"));
+                filteredDeviceCountByPlatform = new DeviceCountByGroupEntry();
+                filteredDeviceCountByPlatform.setGroup(rs.getString("PLATFORM"));
+                filteredDeviceCountByPlatform.setDisplayNameForGroup(rs.getString("PLATFORM").toUpperCase());
+                filteredDeviceCountByPlatform.setDeviceCount(rs.getInt("DEVICE_COUNT"));
+                filteredDeviceCountsByPlatforms.add(filteredDeviceCountByPlatform);
             }
         } finally {
             DeviceManagementDAOUtil.cleanupResources(stmt, rs);
@@ -272,19 +354,21 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
         return filteredDeviceCountsByPlatforms;
     }
 
-    public Map<String, Integer> getFeatureNonCompliantDeviceCountsByPlatforms(String nonCompliantFeatureCode,
+    @Override
-                                        Map<String, Object> filters) throws InvalidParameterException, SQLException {
+    public List<DeviceCountByGroupEntry> getFeatureNonCompliantDeviceCountsByPlatforms(String nonCompliantFeatureCode,
+                                        FilterSet filterSet) throws InvalidParameterValueException, SQLException {
 
         if (nonCompliantFeatureCode == null || "".equals(nonCompliantFeatureCode)) {
-            throw new InvalidParameterException("Non-compliant feature code (nonCompliantFeatureCode) " +
+            throw new InvalidParameterValueException("Non-compliant feature code should not be either null or empty.");
-                "should not be either null or empty.");
         }
 
+        Map<String, Object> filters = this.extractDatabaseFiltersFromBean(filterSet);
+
         Connection con;
         PreparedStatement stmt = null;
         ResultSet rs = null;
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
-        Map<String, Integer> filteredDeviceCountsByPlatforms = new HashMap<>();
+        List<DeviceCountByGroupEntry> filteredDeviceCountsByPlatforms = new ArrayList<>();
         try {
             con = this.getConnection();
             String sql, advancedSqlFiltering = "";
@@ -315,8 +399,13 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
             // executing query
             rs = stmt.executeQuery();
             // fetching query results
+            DeviceCountByGroupEntry filteredDeviceCountByPlatform;
             while (rs.next()) {
-                filteredDeviceCountsByPlatforms.put(rs.getString("PLATFORM"), rs.getInt("DEVICE_COUNT"));
+                filteredDeviceCountByPlatform = new DeviceCountByGroupEntry();
+                filteredDeviceCountByPlatform.setGroup(rs.getString("PLATFORM"));
+                filteredDeviceCountByPlatform.setDisplayNameForGroup(rs.getString("PLATFORM").toUpperCase());
+                filteredDeviceCountByPlatform.setDeviceCount(rs.getInt("DEVICE_COUNT"));
+                filteredDeviceCountsByPlatforms.add(filteredDeviceCountByPlatform);
             }
         } finally {
             DeviceManagementDAOUtil.cleanupResources(stmt, rs);
@@ -324,12 +413,17 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
         return filteredDeviceCountsByPlatforms;
     }
 
-    public Map<String, Integer> getDeviceCountsByOwnershipTypes(Map<String, Object> filters) throws SQLException {
+    @Override
+    public List<DeviceCountByGroupEntry> getDeviceCountsByOwnershipTypes(FilterSet filterSet)
+                                                                throws InvalidParameterValueException, SQLException {
+
+        Map<String, Object> filters = this.extractDatabaseFiltersFromBean(filterSet);
+
         Connection con;
         PreparedStatement stmt = null;
         ResultSet rs = null;
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
-        Map<String, Integer> filteredDeviceCountsByOwnershipTypes = new HashMap<>();
+        List<DeviceCountByGroupEntry> filteredDeviceCountsByOwnershipTypes = new ArrayList<>();
         try {
             con = this.getConnection();
             String sql, advancedSqlFiltering = "";
@@ -359,8 +453,13 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
             // executing query
             rs = stmt.executeQuery();
             // fetching query results
+            DeviceCountByGroupEntry filteredDeviceCountByOwnershipType;
             while (rs.next()) {
-                filteredDeviceCountsByOwnershipTypes.put(rs.getString("OWNERSHIP"), rs.getInt("DEVICE_COUNT"));
+                filteredDeviceCountByOwnershipType = new DeviceCountByGroupEntry();
+                filteredDeviceCountByOwnershipType.setGroup(rs.getString("OWNERSHIP"));
+                filteredDeviceCountByOwnershipType.setDisplayNameForGroup(rs.getString("OWNERSHIP"));
+                filteredDeviceCountByOwnershipType.setDeviceCount(rs.getInt("DEVICE_COUNT"));
+                filteredDeviceCountsByOwnershipTypes.add(filteredDeviceCountByOwnershipType);
             }
         } finally {
             DeviceManagementDAOUtil.cleanupResources(stmt, rs);
@@ -368,19 +467,22 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
         return filteredDeviceCountsByOwnershipTypes;
     }
 
-    public Map<String, Integer> getFeatureNonCompliantDeviceCountsByOwnershipTypes(String nonCompliantFeatureCode,
+    @Override
-                                          Map<String, Object> filters) throws InvalidParameterException, SQLException {
+    public List<DeviceCountByGroupEntry>
+                        getFeatureNonCompliantDeviceCountsByOwnershipTypes(String nonCompliantFeatureCode,
+                                            FilterSet filterSet) throws InvalidParameterValueException, SQLException {
 
         if (nonCompliantFeatureCode == null || "".equals(nonCompliantFeatureCode)) {
-            throw new InvalidParameterException("Non-compliant feature code (nonCompliantFeatureCode) " +
+            throw new InvalidParameterValueException("Non-compliant feature code should not be either null or empty.");
-                    "should not be either null or empty.");
         }
 
+        Map<String, Object> filters = this.extractDatabaseFiltersFromBean(filterSet);
+
         Connection con;
         PreparedStatement stmt = null;
         ResultSet rs = null;
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
-        Map<String, Integer> filteredDeviceCountsByOwnershipTypes = new HashMap<>();
+        List<DeviceCountByGroupEntry> filteredDeviceCountsByOwnershipTypes = new ArrayList<>();
         try {
             con = this.getConnection();
             String sql, advancedSqlFiltering = "";
@@ -411,8 +513,13 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
             // executing query
             rs = stmt.executeQuery();
             // fetching query results
+            DeviceCountByGroupEntry filteredDeviceCountByOwnershipType;
             while (rs.next()) {
-                filteredDeviceCountsByOwnershipTypes.put(rs.getString("OWNERSHIP"), rs.getInt("DEVICE_COUNT"));
+                filteredDeviceCountByOwnershipType = new DeviceCountByGroupEntry();
+                filteredDeviceCountByOwnershipType.setGroup(rs.getString("OWNERSHIP"));
+                filteredDeviceCountByOwnershipType.setDisplayNameForGroup(rs.getString("OWNERSHIP"));
+                filteredDeviceCountByOwnershipType.setDeviceCount(rs.getInt("DEVICE_COUNT"));
+                filteredDeviceCountsByOwnershipTypes.add(filteredDeviceCountByOwnershipType);
             }
         } finally {
             DeviceManagementDAOUtil.cleanupResources(stmt, rs);
@@ -420,24 +527,25 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
         return filteredDeviceCountsByOwnershipTypes;
     }
 
-    public PaginationResult getDevicesWithDetails(Map<String, Object> filters,
+    @Override
-                                      int startIndex, int resultCount) throws InvalidParameterException, SQLException {
+    public PaginationResult getDevicesWithDetails(FilterSet filterSet, int startIndex, int resultCount)
+                                                                throws InvalidParameterValueException, SQLException {
 
         if (startIndex < 0) {
-            throw new InvalidParameterException("Start index (startIndex) should be " +
+            throw new InvalidParameterValueException("Start index should be equal to 0 or greater than that.");
-                "equal to 0 or greater than that.");
         }
 
         if (resultCount < 5) {
-            throw new InvalidParameterException("Result count (resultCount) should be " +
+            throw new InvalidParameterValueException("Result count should be equal to 5 or greater than that.");
-                "equal to 5 or greater than that.");
         }
 
+        Map<String, Object> filters = this.extractDatabaseFiltersFromBean(filterSet);
+
         Connection con;
         PreparedStatement stmt = null;
         ResultSet rs = null;
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
-        List<Map<String, Object>> filteredDevicesWithDetails = new ArrayList<>();
+        List<DetailedDeviceEntry> filteredDevicesWithDetails = new ArrayList<>();
         int totalRecordsCount = 0;
         try {
             con = this.getConnection();
@@ -473,15 +581,16 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
             // executing query
             rs = stmt.executeQuery();
             // fetching query results
-            Map<String, Object> filteredDeviceWithDetails;
+            DetailedDeviceEntry filteredDeviceWithDetails;
             while (rs.next()) {
-                filteredDeviceWithDetails = new HashMap<>();
+                filteredDeviceWithDetails = new DetailedDeviceEntry();
-                filteredDeviceWithDetails.put("device-id", rs.getInt("DEVICE_ID"));
+                filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
-                filteredDeviceWithDetails.put("platform", rs.getString("PLATFORM"));
+                filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
-                filteredDeviceWithDetails.put("ownership", rs.getString("OWNERSHIP"));
+                filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
-                filteredDeviceWithDetails.put("connectivity-details", rs.getString("CONNECTIVITY_STATUS"));
+                filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));
                 filteredDevicesWithDetails.add(filteredDeviceWithDetails);
             }
+
             // fetching total records count
             sql = "SELECT COUNT(DEVICE_ID) AS DEVICE_COUNT FROM DEVICES_VIEW_1 WHERE TENANT_ID = ?";
 
@@ -503,30 +612,30 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
         return paginationResult;
     }
 
+    @Override
     public PaginationResult getFeatureNonCompliantDevicesWithDetails(String nonCompliantFeatureCode,
-                                            Map<String, Object> filters, int startIndex, int resultCount)
+                                                        FilterSet filterSet, int startIndex, int resultCount)
-                                                                throws InvalidParameterException, SQLException {
+                                                                throws InvalidParameterValueException, SQLException {
 
         if (nonCompliantFeatureCode == null || "".equals(nonCompliantFeatureCode)) {
-            throw new InvalidParameterException("Non-compliant feature code (nonCompliantFeatureCode) " +
+            throw new InvalidParameterValueException("Non-compliant feature code should not be either null or empty.");
-                "should not be either null or empty.");
         }
 
         if (startIndex < 0) {
-            throw new InvalidParameterException("Start index (startIndex) should be " +
+            throw new InvalidParameterValueException("Start index should be equal to 0 or greater than that.");
-                "equal to 0 or greater than that.");
         }
 
         if (resultCount < 5) {
-            throw new InvalidParameterException("Result count (resultCount) should be " +
+            throw new InvalidParameterValueException("Result count should be equal to 5 or greater than that.");
-                "equal to 5 or greater than that.");
         }
 
+        Map<String, Object> filters = this.extractDatabaseFiltersFromBean(filterSet);
+
         Connection con;
         PreparedStatement stmt = null;
         ResultSet rs = null;
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
-        List<Map<String, Object>> filteredDevicesWithDetails = new ArrayList<>();
+        List<DetailedDeviceEntry> filteredDevicesWithDetails = new ArrayList<>();
         int totalRecordsCount = 0;
         try {
             con = this.getConnection();
@@ -563,15 +672,16 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
             // executing query
             rs = stmt.executeQuery();
             // fetching query results
-            Map<String, Object> filteredDeviceWithDetails;
+            DetailedDeviceEntry filteredDeviceWithDetails;
             while (rs.next()) {
-                filteredDeviceWithDetails = new HashMap<>();
+                filteredDeviceWithDetails = new DetailedDeviceEntry();
-                filteredDeviceWithDetails.put("device-id", rs.getInt("DEVICE_ID"));
+                filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
-                filteredDeviceWithDetails.put("platform", rs.getString("PLATFORM"));
+                filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
-                filteredDeviceWithDetails.put("ownership", rs.getString("OWNERSHIP"));
+                filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
-                filteredDeviceWithDetails.put("connectivity-details", rs.getString("CONNECTIVITY_STATUS"));
+                filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));
                 filteredDevicesWithDetails.add(filteredDeviceWithDetails);
             }
+
             // fetching total records count
             sql = "SELECT COUNT(DEVICE_ID) AS DEVICE_COUNT FROM DEVICES_VIEW_2 " +
                   "WHERE TENANT_ID = ? AND FEATURE_CODE = ?";
@@ -595,12 +705,17 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
         return paginationResult;
     }
 
-    public List<Map<String, Object>> getDevicesWithDetails(Map<String, Object> filters) throws SQLException {
+    @Override
+    public List<DetailedDeviceEntry> getDevicesWithDetails(FilterSet filterSet)
+                                            throws InvalidParameterValueException, SQLException {
+
+        Map<String, Object> filters = this.extractDatabaseFiltersFromBean(filterSet);
+
         Connection con;
         PreparedStatement stmt = null;
         ResultSet rs = null;
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
-        List<Map<String, Object>> filteredDevicesWithDetails = new ArrayList<>();
+        List<DetailedDeviceEntry> filteredDevicesWithDetails = new ArrayList<>();
         try {
             con = this.getConnection();
             String sql;
@@ -629,13 +744,13 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
             // executing query
             rs = stmt.executeQuery();
             // fetching query results
-            Map<String, Object> filteredDeviceWithDetails;
+            DetailedDeviceEntry filteredDeviceWithDetails;
             while (rs.next()) {
-                filteredDeviceWithDetails = new HashMap<>();
+                filteredDeviceWithDetails = new DetailedDeviceEntry();
-                filteredDeviceWithDetails.put("device-id", rs.getInt("DEVICE_ID"));
+                filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
-                filteredDeviceWithDetails.put("platform", rs.getString("PLATFORM"));
+                filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
-                filteredDeviceWithDetails.put("ownership", rs.getString("OWNERSHIP"));
+                filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
-                filteredDeviceWithDetails.put("connectivity-details", rs.getString("CONNECTIVITY_STATUS"));
+                filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));
                 filteredDevicesWithDetails.add(filteredDeviceWithDetails);
             }
         } finally {
@@ -644,19 +759,21 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
         return filteredDevicesWithDetails;
     }
 
-    public List<Map<String, Object>> getFeatureNonCompliantDevicesWithDetails(String nonCompliantFeatureCode,
+    @Override
-                                        Map<String, Object> filters) throws InvalidParameterException, SQLException {
+    public List<DetailedDeviceEntry> getFeatureNonCompliantDevicesWithDetails(String nonCompliantFeatureCode,
+                                           FilterSet filterSet) throws InvalidParameterValueException, SQLException {
 
         if (nonCompliantFeatureCode == null || "".equals(nonCompliantFeatureCode)) {
-            throw new InvalidParameterException("Non-compliant feature code (nonCompliantFeatureCode) " +
+            throw new InvalidParameterValueException("Non-compliant feature code should not be either null or empty.");
-                "should not be either null or empty.");
         }
 
+        Map<String, Object> filters = this.extractDatabaseFiltersFromBean(filterSet);
+
         Connection con;
         PreparedStatement stmt = null;
         ResultSet rs = null;
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
-        List<Map<String, Object>> filteredDevicesWithDetails = new ArrayList<>();
+        List<DetailedDeviceEntry> filteredDevicesWithDetails = new ArrayList<>();
         try {
             con = this.getConnection();
             String sql;
@@ -687,13 +804,13 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
             // executing query
             rs = stmt.executeQuery();
             // fetching query results
-            Map<String, Object> filteredDeviceWithDetails;
+            DetailedDeviceEntry filteredDeviceWithDetails;
             while (rs.next()) {
-                filteredDeviceWithDetails = new HashMap<>();
+                filteredDeviceWithDetails = new DetailedDeviceEntry();
-                filteredDeviceWithDetails.put("device-id", rs.getInt("DEVICE_ID"));
+                filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
-                filteredDeviceWithDetails.put("platform", rs.getString("PLATFORM"));
+                filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
-                filteredDeviceWithDetails.put("ownership", rs.getString("OWNERSHIP"));
+                filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
-                filteredDeviceWithDetails.put("connectivity-details", rs.getString("CONNECTIVITY_STATUS"));
+                filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));
                 filteredDevicesWithDetails.add(filteredDeviceWithDetails);
             }
         } finally {
@@ -702,6 +819,49 @@ public class GadgetDataServiceDAOImpl implements GadgetDataServiceDAO {
         return filteredDevicesWithDetails;
     }
 
+    private Map<String, Object> extractDatabaseFiltersFromBean(FilterSet filterSet)
+                                                        throws InvalidParameterValueException {
+        if (filterSet == null) {
+            return null;
+        }
+
+        Map<String, Object> filters = new LinkedHashMap<>();
+
+        String connectivityStatus = filterSet.getConnectivityStatus();
+        if (connectivityStatus != null) {
+            filters.put("CONNECTIVITY_STATUS", connectivityStatus);
+        }
+
+        String potentialVulnerability = filterSet.getPotentialVulnerability();
+        if (potentialVulnerability != null) {
+            if (GadgetDataServiceDAOConstants.PotentialVulnerability.NON_COMPLIANT.equals(potentialVulnerability) ||
+                    GadgetDataServiceDAOConstants.PotentialVulnerability.UNMONITORED.equals(potentialVulnerability)) {
+                if (GadgetDataServiceDAOConstants.PotentialVulnerability.NON_COMPLIANT.equals(potentialVulnerability)) {
+                    filters.put("IS_COMPLIANT", 0);
+                } else {
+                    filters.put("POLICY_ID", -1);
+                }
+            } else {
+                throw new InvalidParameterValueException("Invalid use of value for potential vulnerability. " +
+                    "Value of potential vulnerability could only be either " +
+                        GadgetDataServiceDAOConstants.PotentialVulnerability.NON_COMPLIANT + " or " +
+                            GadgetDataServiceDAOConstants.PotentialVulnerability.UNMONITORED + ".");
+            }
+        }
+
+        String platform = filterSet.getPlatform();
+        if (platform != null) {
+            filters.put("PLATFORM", platform);
+        }
+
+        String ownership = filterSet.getOwnership();
+        if (ownership != null) {
+            filters.put("OWNERSHIP", ownership);
+        }
+
+        return filters;
+    }
+
     private Connection getConnection() throws SQLException {
         return GadgetDataServiceDAOFactory.getConnection();
     }

components/device-mgt/org.wso2.carbon.device.mgt.analytics.dashboard/src/main/java/org/wso2/carbon/device/mgt/analytics/dashboard/impl/GadgetDataServiceImpl.java

@@ -20,13 +20,12 @@ package org.wso2.carbon.device.mgt.analytics.dashboard.impl;
 
 import org.wso2.carbon.device.mgt.analytics.dashboard.GadgetDataService;
 import org.wso2.carbon.device.mgt.analytics.dashboard.dao.GadgetDataServiceDAOFactory;
-import org.wso2.carbon.device.mgt.analytics.dashboard.dao.exception.InvalidParameterException;
+import org.wso2.carbon.device.mgt.analytics.dashboard.dao.bean.*;
-import org.wso2.carbon.device.mgt.common.PaginationRequest;
+import org.wso2.carbon.device.mgt.analytics.dashboard.dao.exception.InvalidParameterValueException;
 import org.wso2.carbon.device.mgt.common.PaginationResult;
 
 import java.sql.SQLException;
 import java.util.List;
-import java.util.Map;
 
 /**
  * To be updated...
@@ -34,8 +33,34 @@ import java.util.Map;
 public class GadgetDataServiceImpl implements GadgetDataService {
 
     @Override
-    public int getTotalDeviceCount() throws SQLException {
+    public DeviceCountByGroupEntry getDeviceCount(FilterSet filterSet) throws InvalidParameterValueException, SQLException {
-        int totalDeviceCount;
+        DeviceCountByGroupEntry filteredDeviceCount;
+        try {
+            GadgetDataServiceDAOFactory.openConnection();
+            filteredDeviceCount = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().getDeviceCount(filterSet);
+        } finally {
+            GadgetDataServiceDAOFactory.closeConnection();
+        }
+        return filteredDeviceCount;
+    }
+
+    @Override
+    public DeviceCountByGroupEntry getFeatureNonCompliantDeviceCount(String nonCompliantFeatureCode, FilterSet filterSet)
+                                                                  throws InvalidParameterValueException, SQLException {
+        DeviceCountByGroupEntry featureNonCompliantDeviceCount;
+        try {
+            GadgetDataServiceDAOFactory.openConnection();
+            featureNonCompliantDeviceCount = GadgetDataServiceDAOFactory.
+                    getGadgetDataServiceDAO().getFeatureNonCompliantDeviceCount(nonCompliantFeatureCode, filterSet);
+        } finally {
+            GadgetDataServiceDAOFactory.closeConnection();
+        }
+        return featureNonCompliantDeviceCount;
+    }
+
+    @Override
+    public DeviceCountByGroupEntry getTotalDeviceCount() throws SQLException {
+        DeviceCountByGroupEntry totalDeviceCount;
         try {
             GadgetDataServiceDAOFactory.openConnection();
             totalDeviceCount = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().getTotalDeviceCount();
@@ -46,69 +71,34 @@ public class GadgetDataServiceImpl implements GadgetDataService {
     }
 
     @Override
-    public int getActiveDeviceCount() throws SQLException {
+    public List<DeviceCountByGroupEntry> getDeviceCountsByConnectivityStatuses() throws SQLException {
-        int activeDeviceCount;
+        List<DeviceCountByGroupEntry> deviceCountsByConnectivityStatuses;
         try {
             GadgetDataServiceDAOFactory.openConnection();
-            activeDeviceCount = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().getActiveDeviceCount();
+            deviceCountsByConnectivityStatuses = GadgetDataServiceDAOFactory.
+                    getGadgetDataServiceDAO().getDeviceCountsByConnectivityStatuses();
         } finally {
             GadgetDataServiceDAOFactory.closeConnection();
         }
-        return activeDeviceCount;
+        return deviceCountsByConnectivityStatuses;
     }
 
     @Override
-    public int getInactiveDeviceCount() throws SQLException {
+    public List<DeviceCountByGroupEntry> getDeviceCountsByPotentialVulnerabilities() throws SQLException {
-        int inactiveDeviceCount;
+        List<DeviceCountByGroupEntry> deviceCountsByPotentialVulnerabilities;
         try {
             GadgetDataServiceDAOFactory.openConnection();
-            inactiveDeviceCount = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().getInactiveDeviceCount();
+            deviceCountsByPotentialVulnerabilities = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().
+                getDeviceCountsByPotentialVulnerabilities();
         } finally {
             GadgetDataServiceDAOFactory.closeConnection();
         }
-        return inactiveDeviceCount;
+        return deviceCountsByPotentialVulnerabilities;
-    }
-
-    @Override
-    public int getRemovedDeviceCount() throws SQLException {
-        int removedDeviceCount;
-        try {
-            GadgetDataServiceDAOFactory.openConnection();
-            removedDeviceCount = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().getRemovedDeviceCount();
-        } finally {
-            GadgetDataServiceDAOFactory.closeConnection();
-        }
-        return removedDeviceCount;
-    }
-
-    @Override
-    public int getNonCompliantDeviceCount() throws SQLException {
-        int nonCompliantDeviceCount;
-        try {
-            GadgetDataServiceDAOFactory.openConnection();
-            nonCompliantDeviceCount = GadgetDataServiceDAOFactory.
-                getGadgetDataServiceDAO().getNonCompliantDeviceCount();
-        } finally {
-            GadgetDataServiceDAOFactory.closeConnection();
-        }
-        return nonCompliantDeviceCount;
-    }
-
-    @Override
-    public int getUnmonitoredDeviceCount() throws SQLException {
-        int unmonitoredDeviceCount;
-        try {
-            GadgetDataServiceDAOFactory.openConnection();
-            unmonitoredDeviceCount = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().getUnmonitoredDeviceCount();
-        } finally {
-            GadgetDataServiceDAOFactory.closeConnection();
-        }
-        return unmonitoredDeviceCount;
     }
 
     @Override
     public PaginationResult getNonCompliantDeviceCountsByFeatures(int startIndex, int resultCount)
-                                                            throws SQLException, InvalidParameterException {
+                                                                  throws SQLException, InvalidParameterValueException {
         PaginationResult paginationResult;
         try {
             GadgetDataServiceDAOFactory.openConnection();
@@ -121,38 +111,13 @@ public class GadgetDataServiceImpl implements GadgetDataService {
     }
 
     @Override
-    public int getDeviceCount(Map<String, Object> filters) throws SQLException {
+    public List<DeviceCountByGroupEntry> getDeviceCountsByPlatforms(FilterSet filterSet)
-        int deviceCount;
+                                                                  throws InvalidParameterValueException, SQLException {
-        try {
+        List<DeviceCountByGroupEntry> deviceCountsByPlatforms;
-            GadgetDataServiceDAOFactory.openConnection();
-            deviceCount = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().getDeviceCount(filters);
-        } finally {
-            GadgetDataServiceDAOFactory.closeConnection();
-        }
-        return deviceCount;
-    }
-
-    @Override
-    public int getFeatureNonCompliantDeviceCount(String nonCompliantFeatureCode, Map<String, Object> filters)
-                                                                    throws SQLException, InvalidParameterException {
-        int featureNonCompliantDeviceCount;
-        try {
-            GadgetDataServiceDAOFactory.openConnection();
-            featureNonCompliantDeviceCount = GadgetDataServiceDAOFactory.
-                getGadgetDataServiceDAO().getFeatureNonCompliantDeviceCount(nonCompliantFeatureCode, filters);
-        } finally {
-            GadgetDataServiceDAOFactory.closeConnection();
-        }
-        return featureNonCompliantDeviceCount;
-    }
-
-    @Override
-    public Map<String, Integer> getDeviceCountsByPlatforms(Map<String, Object> filters) throws SQLException {
-        Map<String, Integer> deviceCountsByPlatforms;
         try {
             GadgetDataServiceDAOFactory.openConnection();
             deviceCountsByPlatforms = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().
-                getDeviceCountsByPlatforms(filters);
+                getDeviceCountsByPlatforms(filterSet);
         } finally {
             GadgetDataServiceDAOFactory.closeConnection();
         }
@@ -160,13 +125,13 @@ public class GadgetDataServiceImpl implements GadgetDataService {
     }
 
     @Override
-    public Map<String, Integer> getFeatureNonCompliantDeviceCountsByPlatforms(String nonCompliantFeatureCode,
+    public List<DeviceCountByGroupEntry> getFeatureNonCompliantDeviceCountsByPlatforms(String nonCompliantFeatureCode,
-                                         Map<String, Object> filters) throws SQLException, InvalidParameterException {
+                                             FilterSet filterSet) throws InvalidParameterValueException, SQLException {
-        Map<String, Integer> featureNonCompliantDeviceCountsByPlatforms;
+        List<DeviceCountByGroupEntry> featureNonCompliantDeviceCountsByPlatforms;
         try {
             GadgetDataServiceDAOFactory.openConnection();
             featureNonCompliantDeviceCountsByPlatforms = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().
-                getFeatureNonCompliantDeviceCountsByPlatforms(nonCompliantFeatureCode, filters);
+                getFeatureNonCompliantDeviceCountsByPlatforms(nonCompliantFeatureCode, filterSet);
         } finally {
             GadgetDataServiceDAOFactory.closeConnection();
         }
@@ -174,12 +139,13 @@ public class GadgetDataServiceImpl implements GadgetDataService {
     }
 
     @Override
-    public Map<String, Integer> getDeviceCountsByOwnershipTypes(Map<String, Object> filters) throws SQLException {
+    public List<DeviceCountByGroupEntry> getDeviceCountsByOwnershipTypes(FilterSet filterSet)
-        Map<String, Integer> deviceCountsByOwnershipTypes;
+                                                                 throws InvalidParameterValueException, SQLException {
+        List<DeviceCountByGroupEntry> deviceCountsByOwnershipTypes;
         try {
             GadgetDataServiceDAOFactory.openConnection();
             deviceCountsByOwnershipTypes = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().
-                getDeviceCountsByOwnershipTypes(filters);
+                getDeviceCountsByOwnershipTypes(filterSet);
         } finally {
             GadgetDataServiceDAOFactory.closeConnection();
         }
@@ -187,13 +153,14 @@ public class GadgetDataServiceImpl implements GadgetDataService {
     }
 
     @Override
-    public Map<String, Integer> getFeatureNonCompliantDeviceCountsByOwnershipTypes(String nonCompliantFeatureCode,
+    public List<DeviceCountByGroupEntry>
-                                         Map<String, Object> filters) throws SQLException, InvalidParameterException {
+        getFeatureNonCompliantDeviceCountsByOwnershipTypes(String nonCompliantFeatureCode,
-        Map<String, Integer> featureNonCompliantDeviceCountsByOwnershipTypes;
+                                            FilterSet filterSet) throws SQLException, InvalidParameterValueException {
+        List<DeviceCountByGroupEntry> featureNonCompliantDeviceCountsByOwnershipTypes;
         try {
             GadgetDataServiceDAOFactory.openConnection();
             featureNonCompliantDeviceCountsByOwnershipTypes = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().
-                getFeatureNonCompliantDeviceCountsByOwnershipTypes(nonCompliantFeatureCode, filters);
+                getFeatureNonCompliantDeviceCountsByOwnershipTypes(nonCompliantFeatureCode, filterSet);
         } finally {
             GadgetDataServiceDAOFactory.closeConnection();
         }
@@ -201,13 +168,13 @@ public class GadgetDataServiceImpl implements GadgetDataService {
     }
 
     @Override
-    public PaginationResult getDevicesWithDetails(Map<String, Object> filters,
+    public PaginationResult getDevicesWithDetails(FilterSet filterSet,
-                                     int startIndex, int resultCount) throws InvalidParameterException, SQLException {
+                                int startIndex, int resultCount) throws InvalidParameterValueException, SQLException {
         PaginationResult paginationResult;
         try {
             GadgetDataServiceDAOFactory.openConnection();
             paginationResult = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().
-                getDevicesWithDetails(filters, startIndex, resultCount);
+                getDevicesWithDetails(filterSet, startIndex, resultCount);
         } finally {
             GadgetDataServiceDAOFactory.closeConnection();
         }
@@ -216,13 +183,13 @@ public class GadgetDataServiceImpl implements GadgetDataService {
 
     @Override
     public PaginationResult getFeatureNonCompliantDevicesWithDetails(String nonCompliantFeatureCode,
-                                                Map<String, Object> filters, int startIndex, int resultCount)
+                                                        FilterSet filterSet, int startIndex, int resultCount)
-                                                                    throws InvalidParameterException, SQLException {
+                                                                 throws InvalidParameterValueException, SQLException {
         PaginationResult paginationResult;
         try {
             GadgetDataServiceDAOFactory.openConnection();
             paginationResult = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().
-                    getFeatureNonCompliantDevicesWithDetails(nonCompliantFeatureCode, filters, startIndex, resultCount);
+                getFeatureNonCompliantDevicesWithDetails(nonCompliantFeatureCode, filterSet, startIndex, resultCount);
         } finally {
             GadgetDataServiceDAOFactory.closeConnection();
         }
@@ -230,11 +197,13 @@ public class GadgetDataServiceImpl implements GadgetDataService {
     }
 
     @Override
-    public List<Map<String, Object>> getDevicesWithDetails(Map<String, Object> filters) throws SQLException {
+    public List<DetailedDeviceEntry> getDevicesWithDetails(FilterSet filterSet)
-        List<Map<String, Object>> devicesWithDetails;
+                                                           throws InvalidParameterValueException, SQLException {
+        List<DetailedDeviceEntry> devicesWithDetails;
         try {
             GadgetDataServiceDAOFactory.openConnection();
-            devicesWithDetails = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().getDevicesWithDetails(filters);
+            devicesWithDetails = GadgetDataServiceDAOFactory.
+                    getGadgetDataServiceDAO().getDevicesWithDetails(filterSet);
         } finally {
             GadgetDataServiceDAOFactory.closeConnection();
         }
@@ -242,13 +211,13 @@ public class GadgetDataServiceImpl implements GadgetDataService {
     }
 
     @Override
-    public List<Map<String, Object>> getFeatureNonCompliantDevicesWithDetails(String nonCompliantFeatureCode,
+    public List<DetailedDeviceEntry> getFeatureNonCompliantDevicesWithDetails(String nonCompliantFeatureCode,
-                                         Map<String, Object> filters) throws SQLException, InvalidParameterException {
+                                            FilterSet filterSet) throws InvalidParameterValueException, SQLException {
-        List<Map<String, Object>> featureNonCompliantDevicesWithDetails;
+        List<DetailedDeviceEntry> featureNonCompliantDevicesWithDetails;
         try {
             GadgetDataServiceDAOFactory.openConnection();
             featureNonCompliantDevicesWithDetails = GadgetDataServiceDAOFactory.getGadgetDataServiceDAO().
-                getFeatureNonCompliantDevicesWithDetails(nonCompliantFeatureCode, filters);
+                getFeatureNonCompliantDevicesWithDetails(nonCompliantFeatureCode, filterSet);
         } finally {
             GadgetDataServiceDAOFactory.closeConnection();
         }

components/device-mgt/org.wso2.carbon.device.mgt.analytics.dashboard/src/main/java/org/wso2/carbon/device/mgt/analytics/dashboard/internal/GadgetDataServiceComponent.java

@@ -72,14 +72,14 @@ public class GadgetDataServiceComponent {
         //do nothing
     }
 
-    public void setDataSourceService(DataSourceService dataSourceService) {
+    protected void setDataSourceService(DataSourceService dataSourceService) {
         if (log.isDebugEnabled()) {
             log.debug("Binding org.wso2.carbon.ndatasource.core.DataSourceService...");
         }
         //do nothing
     }
 
-    public void unsetDataSourceService(DataSourceService dataSourceService) {
+    protected void unsetDataSourceService(DataSourceService dataSourceService) {
         if (log.isDebugEnabled()) {
             log.debug("Unbinding org.wso2.carbon.ndatasource.core.DataSourceService...");
         }