Merge with upstream/master

components/application-mgt/org.wso2.carbon.device.application.mgt.api/src/main/java/org/wso2/carbon/device/application/mgt/api/services/ArtifactDownloadAPI.java

@@ -57,7 +57,7 @@ import javax.ws.rs.core.Response;
 public interface ArtifactDownloadAPI {
 
     @GET
-    @Path("/{uuid}/{folderName}/{fileName}")
+    @Path("/{tenantId}/{uuid}/{folderName}/{fileName}")
     @Produces(MediaType.APPLICATION_OCTET_STREAM)
     @ApiOperation(
             produces = MediaType.APPLICATION_OCTET_STREAM,
@@ -81,6 +81,11 @@ public interface ArtifactDownloadAPI {
                             response = ErrorResponse.class)
             })
     Response getArtifact(
+            @ApiParam(
+                    name = "tenantId",
+                    value = "Tenant Id of the application artifact belongs.",
+                    required = true)
+            @PathParam("tenantId") int tenantId,
             @ApiParam(
             name = "uuid",
             value = "UUID of the application release.",

components/application-mgt/org.wso2.carbon.device.application.mgt.api/src/main/java/org/wso2/carbon/device/application/mgt/api/services/impl/ArtifactDownloadAPIImpl.java

@@ -47,14 +47,15 @@ public class ArtifactDownloadAPIImpl implements ArtifactDownloadAPI {
     @GET
     @Override
     @Produces(MediaType.APPLICATION_OCTET_STREAM)
-    @Path("/{uuid}/{folderName}/{fileName}")
+    @Path("/{tenantId}/{uuid}/{folderName}/{fileName}")
     public Response getArtifact(
+            @PathParam("tenantId") int tenantId,
             @PathParam("uuid") String uuid,
             @PathParam("folderName") String folderName,
             @PathParam("fileName") String fileName) {
         AppmDataHandler dataHandler = APIUtil.getDataHandler();
         try {
-            InputStream fileInputStream = dataHandler.getArtifactStream(uuid, folderName, fileName);
+            InputStream fileInputStream = dataHandler.getArtifactStream(tenantId, uuid, folderName, fileName);
             Response.ResponseBuilder response = Response
                     .ok(fileInputStream, MediaType.APPLICATION_OCTET_STREAM);
             response.status(Response.Status.OK);

components/application-mgt/org.wso2.carbon.device.application.mgt.common/src/main/java/org/wso2/carbon/device/application/mgt/common/services/AppmDataHandler.java

@@ -35,6 +35,6 @@ public interface AppmDataHandler {
 
     Map<String, LifecycleState> getLifecycleConfiguration() throws LifecycleManagementException;
 
-    InputStream getArtifactStream(String uuid, String folderName, String artifactName)
+    InputStream getArtifactStream(int tenantId, String uuid, String folderName, String artifactName)
             throws ApplicationManagementException;
 }

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/impl/AppmDataHandlerImpl.java

@@ -60,9 +60,8 @@ public class AppmDataHandlerImpl implements AppmDataHandler {
         return lifecycleStateManager.getLifecycleConfig();
     }
 
-    @Override public InputStream getArtifactStream(String uuid, String folderName, String artifactName)
+    @Override public InputStream getArtifactStream(int tenantId, String uuid, String folderName, String artifactName)
             throws ApplicationManagementException {
-        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true);
         ApplicationStorageManager applicationStorageManager = DAOUtil.getApplicationStorageManager();
         ApplicationReleaseDAO applicationReleaseDAO = ApplicationManagementDAOFactory.getApplicationReleaseDAO();
         String appReleaseHashValue;
@@ -83,9 +82,8 @@ public class AppmDataHandlerImpl implements AppmDataHandler {
             }
             return inputStream;
         } catch (ApplicationManagementDAOException e) {
-            String msg =
+            String msg = "Error occurred when retrieving application release hash value for given application release "
-                    "Error occurred when retrieving application release hash value for given application release UUID: "
+                    + "UUID: " + uuid;
-                            + uuid;
             log.error(msg, e);
             throw new ApplicationManagementException(msg, e);
         } catch (ApplicationStorageManagementException e) {

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/util/APIUtil.java

@@ -353,8 +353,7 @@ public class APIUtil {
         application.setRating(applicationDTO.getAppRating());
         List<ApplicationRelease> applicationReleases = new ArrayList<>();
         for (ApplicationReleaseDTO applicationReleaseDTO : applicationDTO.getApplicationReleaseDTOs()) {
-            ApplicationRelease applicationRelease = releaseDtoToRelease(applicationReleaseDTO);
+            applicationReleases.add(releaseDtoToRelease(applicationReleaseDTO));
-            applicationReleases.add(applicationRelease);
         }
         application.setApplicationReleases(applicationReleases);
         return application;
@@ -362,7 +361,9 @@ public class APIUtil {
 
     public static ApplicationRelease releaseDtoToRelease(ApplicationReleaseDTO applicationReleaseDTO)
             throws ApplicationManagementException {
-        String basePath = getArtifactDownloadBaseURL() + applicationReleaseDTO.getUuid()
+        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true);
+        String basePath =
+                getArtifactDownloadBaseURL() + tenantId + Constants.FORWARD_SLASH + applicationReleaseDTO.getUuid()
                         + Constants.FORWARD_SLASH;
 
         List<String> screenshotPaths = new ArrayList<>();

components/application-mgt/org.wso2.carbon.device.application.mgt.publisher.ui/react-app/src/components/apps/list-apps/AppDetailsDrawer/AppDetailsDrawer.js

@@ -92,7 +92,6 @@ class AppDetailsDrawer extends React.Component {
 
     componentDidMount() {
         this.getCategories();
-        this.getTags();
     }
 
     componentDidUpdate(prevProps, prevState, snapshot) {
@@ -117,7 +116,7 @@ class AppDetailsDrawer extends React.Component {
         ).then(res => {
             if (res.status === 200) {
                 const categories = JSON.parse(res.data.data);
-
+                this.getTags();
                 const globalCategories = categories.map(category => {
                     return (
                         <Option

components/application-mgt/org.wso2.carbon.device.application.mgt.publisher.ui/react-app/src/components/apps/list-apps/Filters.js

@@ -75,8 +75,6 @@ class FiltersForm extends React.Component {
 
     componentDidMount() {
         this.getCategories();
-        this.getTags();
-        this.getDeviceTypes();
     }
 
     getCategories = () => {
@@ -86,6 +84,7 @@ class FiltersForm extends React.Component {
         ).then(res => {
             if (res.status === 200) {
                 let categories = JSON.parse(res.data.data);
+                this.getTags();
                 this.setState({
                     categories: categories,
                     loading: false
@@ -116,6 +115,7 @@ class FiltersForm extends React.Component {
         ).then(res => {
             if (res.status === 200) {
                 let tags = JSON.parse(res.data.data);
+                this.getDeviceTypes();
                 this.setState({
                     tags: tags,
                     loading: false,

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

@@ -681,7 +681,15 @@ public interface GroupManagementService {
                                                "pagination index/offset.",
                                        defaultValue = "5")
                                @QueryParam("limit")
-                                       int limit);
+                                       int limit,
+
+                               @ApiParam(
+                                       name = "requireDeviceProps",
+                                       value = "Boolean flag indicating whether to include device properties \n" +
+                                               " to the device object.",
+                                       required = false)
+                               @QueryParam("requireDeviceProps")
+                                       boolean requireDeviceProps);
 
     @Path("/id/{groupId}/devices/count")
     @GET

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

@@ -249,7 +249,7 @@ public interface DeviceManagementAdminService {
                     List<String> deviceIdentifiers);
 
     @DELETE
-    @Path("/type/{device-type}/id/{device-id}")
+    @Path("/permanent-delete")
     @ApiOperation(
             produces = MediaType.APPLICATION_JSON,
             consumes = MediaType.APPLICATION_JSON,
@@ -282,37 +282,20 @@ public interface DeviceManagementAdminService {
                                             description = "Date and time the resource has been modified the last time.\n" +
                                                           "Used by caches, or in conditional requests."),
                             }),
-                    @ApiResponse(
-                            code = 304,
-                            message = "Not Modified. Empty body because the client already has the latest " +
-                                      "version of the requested resource."),
                     @ApiResponse(
                             code = 400,
                             message = "Bad Request. \n Invalid request or validation error.",
                             response = ErrorResponse.class),
-                    @ApiResponse(
-                            code = 404,
-                            message = "Not Found. \n No device is found under the provided type and id.",
-                            response = ErrorResponse.class),
                     @ApiResponse(
                             code = 500,
                             message = "Internal Server Error. \n " +
                                       "Server error occurred while retrieving information requested device.",
                             response = ErrorResponse.class)
             })
-    Response deleteDevicePermanently(
+    Response deleteDevicesPermanently(
             @ApiParam(
-                    name = "device-type",
+                    name = "Device Identifiers",
-                    value = "The device type, such as ios, android, or windows.",
+                    value = "List of device identifiers.",
                     required = true)
-            @PathParam("device-type")
+                    List<String> deviceIdentifiers);
-            @Size(max = 45)
-                    String deviceType,
-            @ApiParam(
-                    name = "device-id",
-                    value = "The device identifier of the device.",
-                    required = true)
-            @PathParam("device-id")
-            @Size(max = 45)
-                    String deviceId);
 }

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

@@ -652,10 +652,19 @@ public class DeviceManagementServiceImpl implements DeviceManagementService {
         List<Device> devices;
         DeviceList deviceList = new DeviceList();
         try {
+            if(map.getProperties().isEmpty()){
+                if (log.isDebugEnabled()) {
+                    log.debug("No search criteria defined when querying devices.");
+                }
+                return Response.status(Response.Status.BAD_REQUEST).entity("No search criteria defined.").build();
+            }
             DeviceManagementProviderService dms = DeviceMgtAPIUtils.getDeviceManagementService();
             devices = dms.getDevicesBasedOnProperties(map.getProperties());
             if(devices == null || devices.isEmpty()){
-                return Response.status(Response.Status.OK).entity("No device found matching query criteria.").build();
+                if (log.isDebugEnabled()) {
+                    log.debug("No Devices Found for criteria : " + map);
+                }
+                return Response.status(Response.Status.NOT_FOUND).entity("No device found matching query criteria.").build();
             }
         } catch (DeviceManagementException e) {
             String msg = "Error occurred while searching for devices that matches the provided device properties";

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

@@ -204,10 +204,10 @@ public class GroupManagementServiceImpl implements GroupManagementService {
     }
 
     @Override
-    public Response getDevicesOfGroup(int groupId, int offset, int limit) {
+    public Response getDevicesOfGroup(int groupId, int offset, int limit, boolean requireDeviceProps) {
         try {
             GroupManagementProviderService service = DeviceMgtAPIUtils.getGroupManagementProviderService();
-            List<Device> deviceList = service.getDevices(groupId, offset, limit);
+            List<Device> deviceList = service.getDevices(groupId, offset, limit, requireDeviceProps);
             int deviceCount = service.getDeviceCount(groupId);
             DeviceList deviceListWrapper = new DeviceList();
             if (deviceList != null) {

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

@@ -138,26 +138,26 @@ public class DeviceManagementAdminServiceImpl implements DeviceManagementAdminSe
 
     @DELETE
     @Override
-    @Path("/type/{device-type}/id/{device-id}")
+    @Path("/permanent-delete")
-    public Response deleteDevicePermanently(@PathParam("device-type") String deviceType,
+    public Response deleteDevicesPermanently(List<String> deviceIdentifiers) {
-                                 @PathParam("device-id") String deviceId) {
         DeviceManagementProviderService deviceManagementProviderService =
                 DeviceMgtAPIUtils.getDeviceManagementService();
         try {
-            DeviceIdentifier deviceIdentifier = new DeviceIdentifier(deviceId, deviceType);
+            if (!deviceManagementProviderService.deleteDevices(deviceIdentifiers)) {
-            Device persistedDevice = deviceManagementProviderService.getDevice(deviceIdentifier, true);
+                String msg = "Found un-deployed device type.";
-            if (persistedDevice == null) {
-                String msg = "No device found with the device type: " + deviceType +
-                             " having the device ID: " + deviceId + " to permanently delete.";
                 log.error(msg);
-                return Response.status(Response.Status.NOT_FOUND).entity(
+                return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(
                         new ErrorResponse.ErrorResponseBuilder().setMessage(msg).build()).build();
             }
-            boolean response = deviceManagementProviderService.deleteDevice(deviceIdentifier);
+            return Response.status(Response.Status.OK).entity(true).build();
-            return Response.status(Response.Status.OK).entity(response).build();
         } catch (DeviceManagementException e) {
-            String msg = "Error encountered while permanently deleting device of type : " + deviceType + " and " +
+            String msg = "Error encountered while permanently deleting devices";
-                         "ID : " + deviceId;
+            log.error(msg, e);
+            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(
+                    new ErrorResponse.ErrorResponseBuilder().setMessage(msg).build()).build();
+        }
+        catch (InvalidDeviceException e) {
+            String msg = "Found Invalid devices";
             log.error(msg, e);
             return Response.status(Response.Status.BAD_REQUEST).entity(
                     new ErrorResponse.ErrorResponseBuilder().setMessage(msg).build()).build();

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

@@ -266,16 +266,16 @@ public class GroupManagementServiceImplTest {
         PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getGroupManagementProviderService"))
                 .toReturn(groupManagementProviderService);
         Mockito.doReturn(1).when(groupManagementProviderService).getDeviceCount(Mockito.anyInt());
-        Mockito.doReturn(new ArrayList<Device>()).when(groupManagementProviderService).getDevices(1, 0, 10);
+        Mockito.doReturn(new ArrayList<Device>()).when(groupManagementProviderService).getDevices(1, 0, 10, false);
-        Mockito.doReturn(null).when(groupManagementProviderService).getDevices(2, 0, 10);
+        Mockito.doReturn(null).when(groupManagementProviderService).getDevices(2, 0, 10, false);
-        Mockito.doThrow(new GroupManagementException()).when(groupManagementProviderService).getDevices(3, 0, 10);
+        Mockito.doThrow(new GroupManagementException()).when(groupManagementProviderService).getDevices(3, 0, 10, false);
-        Response response = groupManagementService.getDevicesOfGroup(1, 0, 10);
+        Response response = groupManagementService.getDevicesOfGroup(1, 0, 10, false);
         Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
                 "getDevicesOfGroup request failed for a request with valid parameters");
-        response = groupManagementService.getDevicesOfGroup(2, 0, 10);
+        response = groupManagementService.getDevicesOfGroup(2, 0, 10, false);
         Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
                 "getDevicesOfGroup request failed for a request with valid parameters");
-        response = groupManagementService.getDevicesOfGroup(3, 0, 10);
+        response = groupManagementService.getDevicesOfGroup(3, 0, 10, false);
         Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
                 "getDevicesOfGroup request succeded for a request with in-valid parameters");
     }

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

@@ -98,13 +98,11 @@ public interface DeviceManager {
     boolean disenrollDevice(DeviceIdentifier deviceId) throws DeviceManagementException;
 
     /**
-     * Method to delete a particular device from CDM.
+     * Method to delete multiple devices from CDM.
-     *
+     * @param deviceIdentifiers Fully qualified device identifier list
-     * @param deviceId Fully qualified device identifier
-     * @return A boolean indicating the status of the operation.
      * @throws DeviceManagementException If some unusual behaviour is observed while deleting a device
      */
-    boolean deleteDevice(DeviceIdentifier deviceId, Device device) throws DeviceManagementException;
+    void deleteDevices(List<String> deviceIdentifiers) throws DeviceManagementException;
 
     /**
      * Method to retrieve the status of the registration process of a particular device.

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

@@ -523,13 +523,14 @@ public interface DeviceDAO {
     List<Device> getDevicesByIdentifiers(List<String> deviceIdentifiers, int tenantId)
             throws DeviceManagementDAOException;
 
-    /**
+    /***
-     * This method is used to permanently delete the device and its related details
+     * This method is used to permanently delete devices and their related details
-     * @param deviceIdentifier device id
+     * @param deviceIdentifiers List of device identifiers.
-     * @param tenantId tenant id
+     * @param deviceIds list of device ids (primary keys).
-     * @throws DeviceManagementDAOException
+     * @param enrollmentIds list of enrollment ids.
+     * @throws DeviceManagementDAOException when no enrolments are found for the given device.
      */
-    void deleteDevice(DeviceIdentifier deviceIdentifier, int tenantId) throws DeviceManagementDAOException;
+    void deleteDevices(List<String> deviceIdentifiers, List<Integer> deviceIds, List<Integer> enrollmentIds) throws DeviceManagementDAOException;
 
     boolean transferDevice(String deviceType, String deviceId, String owner, int destinationTenantId)
             throws DeviceManagementDAOException, SQLException;

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

@@ -56,6 +56,7 @@ import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Timestamp;
+import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Date;
@@ -1560,9 +1561,8 @@ public abstract class AbstractDeviceDAOImpl implements DeviceDAO {
                 ps.setInt(index++, tenantId);
                 ps.setInt(index, tenantId);
                 try (ResultSet rs = ps.executeQuery()) {
-                    if (rs.next()) {
+                    while (rs.next()) {
-                        Device device = DeviceManagementDAOUtil.loadDevice(rs);
+                        devices.add(DeviceManagementDAOUtil.loadDevice(rs));
-                        devices.add(device);
                     }
                 }
             }
@@ -1573,368 +1573,393 @@ public abstract class AbstractDeviceDAOImpl implements DeviceDAO {
         }
     }
 
-    public void deleteDevice(DeviceIdentifier deviceIdentifier, int tenantId) throws DeviceManagementDAOException {
+    @Override
-        String deviceIdentifierId = deviceIdentifier.getId();
+    public void deleteDevices(List<String> deviceIdentifiers, List<Integer> deviceIds, List<Integer> enrollmentIds)
-        String deviceType = deviceIdentifier.getType();
+            throws DeviceManagementDAOException {
         Connection conn;
         try {
             conn = this.getConnection();
-            int deviceId = getDeviceId(conn, deviceIdentifier, tenantId);
+            if (enrollmentIds.isEmpty()) {
-            if (deviceId == -1) {
+                String msg = "Enrollments not found for the devices: " + deviceIdentifiers;
-                String msg = "Device " + deviceIdentifierId + " of type " + deviceType + " is not found";
                 log.error(msg);
                 throw new DeviceManagementDAOException(msg);
             } else {
-                List<Integer> enrollmentIds = getEnrollmentIds(conn, deviceId, tenantId);
+                removeDeviceDetail(conn, deviceIds);
-                if (enrollmentIds == null || enrollmentIds.isEmpty()) {
-                    String msg = "Enrollments not found for the device " + deviceIdentifierId + " of type "
-                                 + deviceType;
-                    log.error(msg);
-                    throw new DeviceManagementDAOException(msg);
-                } else {
-                    removeDeviceDetail(conn, deviceId);
                 if (log.isDebugEnabled()) {
-                        log.debug("Successfully removed device detail data of device " + deviceIdentifierId
+                    log.debug("Successfully removed device detail data of devices: " + deviceIdentifiers);
-                                  + " of type " + deviceType);
                 }
-                    removeDeviceLocation(conn, deviceId);
+                removeDeviceLocation(conn, deviceIds);
                 if (log.isDebugEnabled()) {
-                        log.debug("Successfully removed device location data of device " + deviceIdentifierId
+                    log.debug("Successfully removed device location data of devices: " + deviceIdentifiers);
-                                  + " of type " + deviceType);
                 }
-                    removeDeviceInfo(conn, deviceId);
+                removeDeviceInfo(conn, deviceIds);
                 if (log.isDebugEnabled()) {
-                        log.debug("Successfully removed device info data of device " + deviceIdentifierId
+                    log.debug("Successfully removed device info data of devices: " + deviceIdentifiers);
-                                  + " of type " + deviceType);
                 }
-                    removeDeviceNotification(conn, deviceId);
+                removeDeviceNotification(conn, deviceIds);
                 if (log.isDebugEnabled()) {
-                        log.debug("Successfully removed device notification data of device " + deviceIdentifierId
+                    log.debug("Successfully removed device notification data of devices: " + deviceIdentifiers);
-                                  + " of type " + deviceType);
                 }
-                    removeDeviceApplicationMapping(conn, deviceId);
+                removeDeviceApplicationMapping(conn, deviceIds);
                 if (log.isDebugEnabled()) {
-                        log.debug("Successfully removed device application mapping data of device "
+                    log.debug("Successfully removed device application mapping data of devices: "
-                                  + deviceIdentifierId + " of type " + deviceType);
+                            + deviceIdentifiers);
                 }
-                    removeDevicePolicyApplied(conn, deviceId);
+                removeDevicePolicyApplied(conn, deviceIds);
                 if (log.isDebugEnabled()) {
-                        log.debug("Successfully removed device applied policy data of device " + deviceIdentifierId
+                    log.debug("Successfully removed device applied policy data of devices: " + deviceIdentifiers);
-                                  + " of type " + deviceType);
                 }
-                    removeDevicePolicy(conn, deviceId);
+                removeDevicePolicy(conn, deviceIds);
                 if (log.isDebugEnabled()) {
-                        log.debug("Successfully removed device policy data of device " + deviceIdentifierId
+                    log.debug("Successfully removed device policy data of devices: " + deviceIdentifiers);
-                                  + " of type " + deviceType);
                 }
                 if (log.isDebugEnabled()) {
-                        log.debug("Starting to remove " + enrollmentIds.size() + " enrollment data of device "
+                    log.debug("Starting to remove " + enrollmentIds.size() + " enrollment data of devices with " +
-                                  + deviceIdentifierId + " of type " + deviceType);
+                            "identifiers: " + deviceIdentifiers);
-                    }
-                    for (Integer enrollmentId : enrollmentIds) {
-                        removeEnrollmentDeviceDetail(conn, enrollmentId);
-                        removeEnrollmentDeviceLocation(conn, enrollmentId);
-                        removeEnrollmentDeviceInfo(conn, enrollmentId);
-                        removeEnrollmentDeviceApplicationMapping(conn, enrollmentId);
-                        removeDeviceOperationResponse(conn, enrollmentId);
-                        removeEnrollmentOperationMapping(conn, enrollmentId);
                 }
+                removeEnrollmentDeviceDetail(conn, enrollmentIds);
+                removeEnrollmentDeviceLocation(conn, enrollmentIds);
+                removeEnrollmentDeviceInfo(conn, enrollmentIds);
+                removeEnrollmentDeviceApplicationMapping(conn, enrollmentIds);
+                removeDeviceOperationResponse(conn, enrollmentIds);
+                removeEnrollmentOperationMapping(conn, enrollmentIds);
                 if (log.isDebugEnabled()) {
                     log.debug("Successfully removed enrollment device details, enrollment device location," +
                             "enrollment device info, enrollment device application mapping, " +
-                                  "enrollment device operation response, enrollment operation mapping data of device "
+                            "enrollment device operation response, enrollment operation mapping data of " +
-                                  + deviceIdentifierId + " of type " + deviceType);
+                            "devices with identifiers:  " + deviceIdentifiers);
                 }
-                    removeDeviceEnrollment(conn, deviceId);
+                removeDeviceEnrollment(conn, deviceIds);
                 if (log.isDebugEnabled()) {
-                        log.debug("Successfully removed device enrollment data of device " + deviceIdentifierId
+                    log.debug("Successfully removed device enrollment data of devices: " + deviceIdentifiers);
-                                  + " of type " + deviceType);
                 }
-                    removeDeviceGroupMapping(conn, deviceId);
+                removeDeviceGroupMapping(conn, deviceIds);
                 if (log.isDebugEnabled()) {
-                        log.debug("Successfully removed device group mapping data of device " + deviceIdentifierId
+                    log.debug("Successfully removed device group mapping data of devices: " + deviceIdentifiers);
-                                  + " of type " + deviceType);
                 }
-                    removeDevice(conn, deviceId);
+                removeDevice(conn, deviceIds);
                 if (log.isDebugEnabled()) {
-                        log.debug("Successfully permanently deleted the device of device " + deviceIdentifierId
+                    log.debug("Successfully permanently deleted the device of devices: " + deviceIdentifiers);
-                                  + " of type " + deviceType);
-                    }
                 }
             }
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while deleting the device " + deviceIdentifierId
+            String msg ="Error occurred while deleting the devices: " + deviceIdentifiers;
-                                                   + " of type " + deviceType, e);
+            log.error(msg,e);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private int getDeviceId(Connection conn, DeviceIdentifier deviceIdentifier, int tenantId)
+    /***
-            throws DeviceManagementDAOException {
+     * This method removes records of a given list of devices from the DM_DEVICE_DETAIL table
-        PreparedStatement stmt = null;
+     * @param conn Connection object
-        ResultSet rs = null;
+     * @param deviceIds list of device ids (primary keys)
-        int deviceId = -1;
+     * @throws DeviceManagementDAOException if deletion fails
-        try {
+     */
-            String sql = "SELECT ID FROM DM_DEVICE WHERE DEVICE_IDENTIFICATION = ? AND TENANT_ID = ?";
+    private void removeDeviceDetail(Connection conn, List<Integer> deviceIds) throws DeviceManagementDAOException {
-            stmt = conn.prepareStatement(sql);
-            stmt.setString(1, deviceIdentifier.getId());
-            stmt.setInt(2, tenantId);
-            rs = stmt.executeQuery();
-            if (rs.next()) {
-                deviceId = rs.getInt("ID");
-            }
-        } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while retrieving device id of the device", e);
-        } finally {
-            DeviceManagementDAOUtil.cleanupResources(stmt, rs);
-        }
-        return deviceId;
-    }
-
-    private List<Integer> getEnrollmentIds(Connection conn, int deviceId, int tenantId) throws DeviceManagementDAOException {
-        PreparedStatement stmt = null;
-        ResultSet rs = null;
-        List<Integer> enrollmentIds = new ArrayList<>();
-        try {
-            String sql = "SELECT ID FROM DM_ENROLMENT WHERE DEVICE_ID = ? AND TENANT_ID = ?";
-            stmt = conn.prepareStatement(sql);
-            stmt.setInt(1, deviceId);
-            stmt.setInt(2, tenantId);
-            rs = stmt.executeQuery();
-            while (rs.next()) {
-                enrollmentIds.add(rs.getInt("ID"));
-            }
-        } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while retrieving enrollment id of the device", e);
-        } finally {
-            DeviceManagementDAOUtil.cleanupResources(stmt, rs);
-        }
-        return enrollmentIds;
-    }
-
-    private void removeDeviceDetail(Connection conn, int deviceId) throws DeviceManagementDAOException {
-        PreparedStatement stmt = null;
-        try {
         String sql = "DELETE FROM DM_DEVICE_DETAIL WHERE DEVICE_ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, deviceId);
+            executeBatchOperation(conn, sql, deviceIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing device detail", e);
+            String msg = "Error occurred while removing device details.";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private void removeDeviceLocation(Connection conn, int deviceId) throws DeviceManagementDAOException {
+    /***
-        PreparedStatement stmt = null;
+     * This method removes records of a given list of devices from the DM_DEVICE_LOCATION table
-        try {
+     * @param conn Connection object
+     * @param deviceIds list of device ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeDeviceLocation(Connection conn, List<Integer> deviceIds) throws DeviceManagementDAOException {
         String sql = "DELETE FROM DM_DEVICE_LOCATION WHERE DEVICE_ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, deviceId);
+            executeBatchOperation(conn, sql, deviceIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing device location", e);
+            String msg = "Error occurred while obtaining locations of devices.";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private void removeDeviceInfo(Connection conn, int deviceId) throws DeviceManagementDAOException {
+    /***
-        PreparedStatement stmt = null;
+     * This method removes records of a given list of devices from the DM_DEVICE_INFO table
-        try {
+     * @param conn Connection object
+     * @param deviceIds list of device ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeDeviceInfo(Connection conn, List<Integer> deviceIds) throws DeviceManagementDAOException {
         String sql = "DELETE FROM DM_DEVICE_INFO WHERE DEVICE_ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, deviceId);
+            executeBatchOperation(conn, sql, deviceIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing device info", e);
+            String msg = "Error occurred while removing device info.";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private void removeDeviceNotification(Connection conn, int deviceId) throws DeviceManagementDAOException {
+    /***
-        PreparedStatement stmt = null;
+     * This method removes records of a given list of devices from the DM_NOTIFICATION table
-        try {
+     * @param conn Connection object
+     * @param deviceIds list of device ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeDeviceNotification(Connection conn, List<Integer> deviceIds) throws DeviceManagementDAOException {
         String sql = "DELETE FROM DM_NOTIFICATION WHERE DEVICE_ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, deviceId);
+            executeBatchOperation(conn, sql, deviceIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing device notification", e);
+            String msg = "Error occurred while removing device notifications.";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
-        }
         }
 
-    private void removeDeviceApplicationMapping(Connection conn, int deviceId) throws DeviceManagementDAOException {
+    }
-        PreparedStatement stmt = null;
+
-        try {
+    /***
+     * This method removes records of a given list of devices from the DM_DEVICE_APPLICATION_MAPPING table
+     * @param conn Connection object
+     * @param deviceIds list of device ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeDeviceApplicationMapping(Connection conn, List<Integer> deviceIds)
+            throws DeviceManagementDAOException {
         String sql = "DELETE FROM DM_DEVICE_APPLICATION_MAPPING WHERE DEVICE_ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, deviceId);
+            executeBatchOperation(conn, sql, deviceIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing device application mapping", e);
+            String msg = "Error occurred while removing device application mapping";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private void removeDevicePolicyApplied(Connection conn, int deviceId) throws DeviceManagementDAOException {
+    /***
-        PreparedStatement stmt = null;
+     * This method removes records of a given list of devices from the DM_DEVICE_POLICY_APPLIED table
-        try {
+     * @param conn Connection object
+     * @param deviceIds list of device ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeDevicePolicyApplied(Connection conn, List<Integer> deviceIds)
+            throws DeviceManagementDAOException {
         String sql = "DELETE FROM DM_DEVICE_POLICY_APPLIED WHERE DEVICE_ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, deviceId);
+            executeBatchOperation(conn, sql, deviceIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing device policy applied", e);
+            String msg = "Error occurred while removing policies applied on devices";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private void removeDevicePolicy(Connection conn, int deviceId) throws DeviceManagementDAOException {
+    /***
-        PreparedStatement stmt = null;
+     * This method removes records of a given list of devices from the DM_DEVICE_POLICY table
-        try {
+     * @param conn Connection object
+     * @param deviceIds list of device ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeDevicePolicy(Connection conn, List<Integer> deviceIds) throws DeviceManagementDAOException {
         String sql = "DELETE FROM DM_DEVICE_POLICY WHERE DEVICE_ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, deviceId);
+            executeBatchOperation(conn, sql, deviceIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing device policy", e);
+            String msg = "Error occurred while removing policies of devices";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private void removeEnrollmentDeviceDetail(Connection conn, int enrollmentId) throws DeviceManagementDAOException {
+    /***
-        PreparedStatement stmt = null;
+     * This method removes records of a given list of enrollments from the DM_DEVICE_DETAIL table
-        try {
+     * @param conn Connection object
+     * @param enrollmentIds list of enrollment ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeEnrollmentDeviceDetail(Connection conn, List<Integer> enrollmentIds)
+            throws DeviceManagementDAOException {
         String sql = "DELETE FROM DM_DEVICE_DETAIL WHERE ENROLMENT_ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, enrollmentId);
+            executeBatchOperation(conn, sql, enrollmentIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing enrollment device detail", e);
+            String msg = "Error occurred while removing enrollment details of devices";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private void removeEnrollmentDeviceLocation(Connection conn, int enrollmentId) throws DeviceManagementDAOException {
+    /***
-        PreparedStatement stmt = null;
+     * This method removes records of a given list of enrollments from the DM_DEVICE_LOCATION table
-        try {
+     * @param conn Connection object
+     * @param enrollmentIds list of enrollment ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeEnrollmentDeviceLocation(Connection conn, List<Integer> enrollmentIds)
+            throws DeviceManagementDAOException {
         String sql = "DELETE FROM DM_DEVICE_LOCATION WHERE ENROLMENT_ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, enrollmentId);
+            executeBatchOperation(conn, sql, enrollmentIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing enrollment device location", e);
+            String msg = "Error occurred while removing enrollment locations of devices";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private void removeEnrollmentDeviceInfo(Connection conn, int enrollmentId) throws DeviceManagementDAOException {
+    /***
-        PreparedStatement stmt = null;
+     * This method removes records of a given list of enrollments from the DM_DEVICE_INFO table
-        try {
+     * @param conn Connection object
+     * @param enrollmentIds list of enrollment ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeEnrollmentDeviceInfo(Connection conn, List<Integer> enrollmentIds)
+            throws DeviceManagementDAOException {
         String sql = "DELETE FROM DM_DEVICE_INFO WHERE ENROLMENT_ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, enrollmentId);
+            executeBatchOperation(conn, sql, enrollmentIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing enrollment device info", e);
+            String msg = "Error occurred while removing enrollment info of devices";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private void removeEnrollmentDeviceApplicationMapping(Connection conn, int enrollmentId)
+    /***
+     * This method removes records of a given list of enrollments from the DM_DEVICE_APPLICATION_MAPPING table
+     * @param conn Connection object
+     * @param enrollmentIds list of enrollment ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeEnrollmentDeviceApplicationMapping(Connection conn, List<Integer> enrollmentIds)
             throws DeviceManagementDAOException {
-        PreparedStatement stmt = null;
-        try {
         String sql = "DELETE FROM DM_DEVICE_APPLICATION_MAPPING WHERE ENROLMENT_ID = ?";
-            stmt = conn.prepareStatement(sql);
-            stmt.setInt(1, enrollmentId);
-            stmt.executeUpdate();
-        } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing enrollment device application " +
-                                                   "mapping", e);
-        } finally {
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
-        }
-    }
-
-    private void removeDeviceOperationResponse(Connection conn, int enrollmentId) throws DeviceManagementDAOException {
-        PreparedStatement stmt = null;
         try {
-            String sql = "DELETE FROM DM_DEVICE_OPERATION_RESPONSE WHERE ENROLMENT_ID = ?";
+            executeBatchOperation(conn, sql, enrollmentIds);
-            stmt = conn.prepareStatement(sql);
-            stmt.setInt(1, enrollmentId);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing device operation response", e);
+            String msg = "Error occurred while removing enrollment device application mapping";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private void removeEnrollmentOperationMapping(Connection conn, int enrollmentId)
+    /***
+     * This method removes records of a given list of enrollments from the DM_DEVICE_OPERATION_RESPONSE table
+     * @param conn Connection object
+     * @param enrollmentIds list of enrollment ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeDeviceOperationResponse(Connection conn, List<Integer> enrollmentIds)
             throws DeviceManagementDAOException {
-        PreparedStatement stmt = null;
+        String sql = "DELETE FROM DM_DEVICE_OPERATION_RESPONSE WHERE ENROLMENT_ID = ?";
         try {
+            executeBatchOperation(conn, sql, enrollmentIds);
+        } catch (SQLException e) {
+            String msg = "Error occurred while removing device operation response";
+            log.error(msg, e);
+            throw new DeviceManagementDAOException(msg, e);
+        }
+    }
+
+    /***
+     * This method removes records of a given list of enrollments from the DM_ENROLMENT_OP_MAPPING table
+     * @param conn Connection object
+     * @param enrollmentIds list of enrollment ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeEnrollmentOperationMapping(Connection conn, List<Integer> enrollmentIds)
+            throws DeviceManagementDAOException {
         String sql = "DELETE FROM DM_ENROLMENT_OP_MAPPING WHERE ENROLMENT_ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, enrollmentId);
+            executeBatchOperation(conn, sql, enrollmentIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing enrollment operation mapping", e);
+            String msg = "Error occurred while removing enrollment operation mapping";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private void removeDeviceEnrollment(Connection conn, int deviceId) throws DeviceManagementDAOException {
+    /***
-        PreparedStatement stmt = null;
+     * This method removes records of a given list of enrollments from the DM_ENROLMENT table
-        try {
+     * @param conn Connection object
+     * @param enrollmentIds list of enrollment ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeDeviceEnrollment(Connection conn, List<Integer> enrollmentIds)
+            throws DeviceManagementDAOException {
         String sql = "DELETE FROM DM_ENROLMENT WHERE DEVICE_ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, deviceId);
+            executeBatchOperation(conn, sql, enrollmentIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing device enrollment", e);
+            String msg = "Error occurred while removing enrollments of devices";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private void removeDeviceGroupMapping(Connection conn, int deviceId) throws DeviceManagementDAOException {
+    /***
-        PreparedStatement stmt = null;
+     * This method removes records of a given list of devices from the DM_DEVICE_GROUP_MAP table
-        try {
+     * @param conn Connection object
+     * @param deviceIds list of device ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeDeviceGroupMapping(Connection conn, List<Integer> deviceIds) throws DeviceManagementDAOException {
         String sql = "DELETE FROM DM_DEVICE_GROUP_MAP WHERE DEVICE_ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, deviceId);
+            executeBatchOperation(conn, sql, deviceIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing device group mapping", e);
+            String msg = "Error occurred while removing device group mapping";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
         }
     }
 
-    private void removeDevice(Connection conn, int deviceId) throws DeviceManagementDAOException {
+    /***
-        PreparedStatement stmt = null;
+     * This method removes records of a given list of devices from the DM_DEVICE table
-        try {
+     * @param conn Connection object
+     * @param deviceIds list of device ids (primary keys)
+     * @throws DeviceManagementDAOException if deletion fails
+     */
+    private void removeDevice(Connection conn, List<Integer> deviceIds) throws DeviceManagementDAOException {
         String sql = "DELETE FROM DM_DEVICE WHERE ID = ?";
-            stmt = conn.prepareStatement(sql);
+        try {
-            stmt.setInt(1, deviceId);
+            executeBatchOperation(conn, sql, deviceIds);
-            stmt.executeUpdate();
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while removing device", e);
+            String msg = "Error occurred while removing devices.";
-        } finally {
+            log.error(msg, e);
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            throw new DeviceManagementDAOException(msg, e);
+        }
+    }
+
+    /***
+     * This method executes batch operations for a given list of primary keys
+     * where the statement only has one param of type int, following the given pattern:
+     *    DELETE FROM TABLE WHERE ID = ?
+     * @param sql SQL statement
+     * @param conn Connection object
+     * @param identifiers list of device ids (primary keys)
+     * @throws SQLException if deletion fails.
+     */
+    private void executeBatchOperation(Connection conn, String sql, List<Integer> identifiers) throws SQLException {
+        try (PreparedStatement ps = conn.prepareStatement(sql)) {
+            if (conn.getMetaData().supportsBatchUpdates()) {
+                for (int identifier : identifiers) {
+                    ps.setInt(1, identifier);
+                    ps.addBatch();
+                }
+                for (int i : ps.executeBatch()) {
+                    if (i == 0 || i == Statement.SUCCESS_NO_INFO || i == Statement.EXECUTE_FAILED) {
+                        break;
+                    }
+                }
+            } else {
+                for (int enrollmentId : identifiers) {
+                    ps.setInt(1, enrollmentId);
+                    if (ps.executeUpdate() == 0) {
+                        break;
+                    }
+                }
+            }
         }
     }
 

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

@@ -38,7 +38,6 @@ import java.util.List;
  * This class represents implementation of GroupDAO
  */
 public class GenericGroupDAOImpl extends AbstractGroupDAOImpl {
-
     @Override
     public List<DeviceGroup> getGroups(GroupPaginationRequest request, int tenantId)
             throws GroupManagementDAOException {

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

@@ -598,7 +598,7 @@ public interface DeviceManagementProviderService {
 
     boolean disenrollDevice(DeviceIdentifier deviceId) throws DeviceManagementException;
 
-    boolean deleteDevice(DeviceIdentifier deviceId) throws DeviceManagementException;
+    boolean deleteDevices(List<String> deviceIdentifiers) throws DeviceManagementException, InvalidDeviceException;
 
     boolean isEnrolled(DeviceIdentifier deviceId) throws DeviceManagementException;
 

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

@@ -101,6 +101,7 @@ import org.wso2.carbon.device.mgt.common.type.mgt.DeviceTypePlatformDetails;
 import org.wso2.carbon.device.mgt.common.type.mgt.DeviceTypePlatformVersion;
 import org.wso2.carbon.device.mgt.core.DeviceManagementConstants;
 import org.wso2.carbon.device.mgt.core.DeviceManagementPluginRepository;
+import org.wso2.carbon.device.mgt.core.cache.DeviceCacheKey;
 import org.wso2.carbon.device.mgt.core.cache.impl.DeviceCacheManagerImpl;
 import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
 import org.wso2.carbon.device.mgt.core.config.DeviceManagementConfig;
@@ -147,6 +148,7 @@ import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Arrays;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
@@ -524,73 +526,91 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
     }
 
     @Override
-    public boolean deleteDevice(DeviceIdentifier deviceId) throws DeviceManagementException {
+    public boolean deleteDevices(List<String> deviceIdentifiers) throws DeviceManagementException, InvalidDeviceException {
-        if (deviceId == null) {
+        List<Integer> deviceIds = new ArrayList<>();
-            String msg = "Required values are not set to permanently delete device";
+        List<Integer> enrollmentIds = new ArrayList<>();
-            log.error(msg);
+        Map<String, List<String>> deviceIdentifierMap = new HashMap<>();
-            throw new DeviceManagementException(msg);
+        Map<String, DeviceManager> deviceManagerMap = new HashMap<>();
-        }
+        List<DeviceCacheKey> deviceCacheKeyList = new ArrayList<>();
-        if (log.isDebugEnabled()) {
-            log.debug("Permanently deleting device: " + deviceId.getId() + " of type '" + deviceId.getType() + "'");
-        }
-        DeviceManager deviceManager = this.getDeviceManager(deviceId.getType());
-        if (deviceManager == null) {
-            if (log.isDebugEnabled()) {
-                log.debug("Device Manager associated with the device type '" + deviceId.getType() + "' is null. " +
-                          "Therefore, not attempting method 'deleteDevice'");
-            }
-            return false;
-        }
-
         int tenantId = this.getTenantId();
-
+        List<Device> existingDevices;
-        Device device = this.getDevice(deviceId, false);
-        if (device == null) {
-            if (log.isDebugEnabled()) {
-                log.debug("Device not found for id '" + deviceId.getId() + "'");
-            }
-            return false;
-        }
-
-        if (!device.getEnrolmentInfo().getStatus().equals(EnrolmentInfo.Status.REMOVED)) {
-            String msg = "Device " + deviceId.getId() + " of type " + deviceId.getType() + " is not dis-enrolled to " +
-                         "permanently delete the device";
-            log.error(msg);
-            throw new DeviceManagementException(msg);
-        } else {
         try {
             DeviceManagementDAOFactory.beginTransaction();
-                deviceDAO.deleteDevice(deviceId, tenantId);
+            existingDevices = deviceDAO.getDevicesByIdentifiers(deviceIdentifiers, tenantId);
+            if (existingDevices.size() != deviceIdentifiers.size()) {
+                for (Device device : existingDevices) {
+                    deviceIdentifiers.remove(device.getDeviceIdentifier());
+                }
+                String msg =
+                        "Couldn't find device ids for all the requested device identifiers. " +
+                                "Therefore payload should contain device identifiers which are not in the system. " +
+                                "Invalid device identifiers are " + deviceIdentifiers.toString();
+                log.error(msg);
+                DeviceManagementDAOFactory.rollbackTransaction();
+                throw new InvalidDeviceException(msg);
+            }
+            for (Device device : existingDevices) {
+                if (!device.getEnrolmentInfo().getStatus().equals(EnrolmentInfo.Status.REMOVED)) {
+                    String msg = "Device " + device.getDeviceIdentifier() + " of type " + device.getType()
+                            + " is not dis-enrolled to permanently delete the device";
+                    log.error(msg);
+                    DeviceManagementDAOFactory.rollbackTransaction();
+                    throw new InvalidDeviceException(msg);
+                }
+                DeviceCacheKey deviceCacheKey = new DeviceCacheKey();
+                deviceCacheKey.setDeviceId(device.getDeviceIdentifier());
+                deviceCacheKey.setDeviceType(device.getType());
+                deviceCacheKey.setTenantId(tenantId);
+                deviceCacheKeyList.add(deviceCacheKey);
+                deviceIds.add(device.getId());
+                enrollmentIds.add(device.getEnrolmentInfo().getId());
+                if (deviceIdentifierMap.containsKey(device.getType())) {
+                    deviceIdentifierMap.get(device.getType()).add(device.getDeviceIdentifier());
+                } else {
+                    deviceIdentifierMap.put(device.getType(),
+                            new ArrayList<>(Arrays.asList(device.getDeviceIdentifier())));
+                    DeviceManager deviceManager = this.getDeviceManager(device.getType());
+                    if (deviceManager == null) {
+                        if (log.isDebugEnabled()) {
+                            log.debug("Device Manager associated with the device type '"
+                                    + device.getType() + "' is null. Therefore, not attempting method 'deleteDevice'");
+                        }
+                        return false;
+                    }
+                    deviceManagerMap.put(device.getType(), deviceManager);
+                }
+            }
+            //deleting device from the core
+            deviceDAO.deleteDevices(deviceIdentifiers, deviceIds, enrollmentIds);
+            for (Map.Entry<String, DeviceManager> entry : deviceManagerMap.entrySet()) {
                 try {
-                    deviceManager.deleteDevice(deviceId, device);
+                    // deleting device from the plugin level
+                    entry.getValue().deleteDevices(deviceIdentifierMap.get(entry.getKey()));
                 } catch (DeviceManagementException e) {
-                    String msg = "Error occurred while permanently deleting '" + deviceId.getType() +
+                    String msg = "Error occurred while permanently deleting '" + entry.getKey() +
-                                 "' device with the identifier '" + deviceId.getId() + "' in plugin.";
+                            "' devices with the identifiers: '" + deviceIdentifierMap.get(entry.getKey())
+                            + "' in plugin.";
                     log.error(msg, e);
+                    // a DeviceManagementException is thrown when the device deletion fails from the plugin level.
+                    // Here, that exception is caught and a DeviceManagementDAOException is thrown
                     throw new DeviceManagementDAOException(msg, e);
                 }
+            }
             DeviceManagementDAOFactory.commitTransaction();
-                this.removeDeviceFromCache(deviceId);
+            this.removeDevicesFromCache(deviceCacheKeyList);
-            } catch (DeviceManagementDAOException e) {
+            return true;
-                DeviceManagementDAOFactory.rollbackTransaction();
-                String msg = "Error occurred while permanently deleting '" + deviceId.getType() +
-                             "' device with the identifier '" + deviceId.getId() + "'";
-                log.error(msg, e);
-                throw new DeviceManagementException(msg, e);
         } catch (TransactionManagementException e) {
             String msg = "Error occurred while initiating transaction";
             log.error(msg, e);
             throw new DeviceManagementException(msg, e);
-            } catch (Exception e) {
+        } catch (DeviceManagementDAOException e) {
-                String msg = "Error occurred while permanently deleting device: " + deviceId.getId();
+            DeviceManagementDAOFactory.rollbackTransaction();
+            String msg = "Error occurred while permanently deleting '" + deviceIdentifiers +
+                    "' devices";
             log.error(msg, e);
             throw new DeviceManagementException(msg, e);
-            } finally {
-                DeviceManagementDAOFactory.closeConnection();
         }
     }
-        return true;
-    }
 
     @Override
     public boolean isEnrolled(DeviceIdentifier deviceId) throws DeviceManagementException {
@@ -2979,6 +2999,14 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
         DeviceCacheManagerImpl.getInstance().removeDeviceFromCache(deviceIdentifier, this.getTenantId());
     }
 
+    /***
+     * This method removes a given list of devices from the cache
+     * @param deviceList list of DeviceCacheKey objects
+     */
+    private void removeDevicesFromCache(List<DeviceCacheKey> deviceList) {
+        DeviceCacheManagerImpl.getInstance().removeDevicesFromCache(deviceList);
+    }
+
     @Override
     public List<GeoCluster> findGeoClusters(String deviceType, GeoCoordinate southWest, GeoCoordinate northEast,
                                             int geohashLength) throws DeviceManagementException {

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

@@ -164,7 +164,7 @@ public interface GroupManagementProviderService {
      * @return list of devices in group.
      * @throws GroupManagementException
      */
-    List<Device> getDevices(int groupId, int startIndex, int rowCount) throws GroupManagementException;
+    List<Device> getDevices(int groupId, int startIndex, int rowCount, boolean requireDeviceProps) throws GroupManagementException;
 
     List<Device> getAllDevicesOfGroup(String groupName) throws GroupManagementException;
 

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

@@ -36,6 +36,8 @@ import org.wso2.carbon.device.mgt.common.group.mgt.GroupAlreadyExistException;
 import org.wso2.carbon.device.mgt.common.group.mgt.GroupManagementException;
 import org.wso2.carbon.device.mgt.common.group.mgt.GroupNotExistException;
 import org.wso2.carbon.device.mgt.common.group.mgt.RoleDoesNotExistException;
+import org.wso2.carbon.device.mgt.core.dao.DeviceDAO;
+import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOFactory;
 import org.wso2.carbon.device.mgt.core.dao.GroupDAO;
 import org.wso2.carbon.device.mgt.core.dao.GroupManagementDAOException;
 import org.wso2.carbon.device.mgt.core.dao.GroupManagementDAOFactory;
@@ -56,12 +58,14 @@ public class GroupManagementProviderServiceImpl implements GroupManagementProvid
     private static Log log = LogFactory.getLog(GroupManagementProviderServiceImpl.class);
 
     private GroupDAO groupDAO;
+    private DeviceDAO deviceDAO;
 
     /**
      * Set groupDAO from GroupManagementDAOFactory when class instantiate.
      */
     public GroupManagementProviderServiceImpl() {
         this.groupDAO = GroupManagementDAOFactory.getGroupDAO();
+        this.deviceDAO = DeviceManagementDAOFactory.getDeviceDAO();
     }
 
     /**
@@ -627,7 +631,7 @@ public class GroupManagementProviderServiceImpl implements GroupManagementProvid
      * {@inheritDoc}
      */
     @Override
-    public List<Device> getDevices(int groupId, int startIndex, int rowCount)
+    public List<Device> getDevices(int groupId, int startIndex, int rowCount, boolean requireDeviceProps)
             throws GroupManagementException {
         if (log.isDebugEnabled()) {
             log.debug("Group devices of group: " + groupId + " start index " + startIndex + " row count " + rowCount);
@@ -638,6 +642,16 @@ public class GroupManagementProviderServiceImpl implements GroupManagementProvid
             rowCount = DeviceManagerUtil.validateDeviceListPageSize(rowCount);
             GroupManagementDAOFactory.openConnection();
             devices = this.groupDAO.getDevices(groupId, startIndex, rowCount, tenantId);
+
+            if(requireDeviceProps) {
+                DeviceManagementDAOFactory.openConnection();
+                for (Device device : devices) {
+                    Device retrievedDevice = deviceDAO.getDeviceProps(device.getDeviceIdentifier(), tenantId);
+                    if (retrievedDevice != null && !retrievedDevice.getProperties().isEmpty()) {
+                        device.setProperties(retrievedDevice.getProperties());
+                    }
+                }
+            }
         } catch (GroupManagementDAOException | SQLException | DeviceManagementException e) {
             String msg = "Error occurred while getting devices in group.";
             log.error(msg, e);
@@ -648,6 +662,9 @@ public class GroupManagementProviderServiceImpl implements GroupManagementProvid
             throw new GroupManagementException(msg, e);
         } finally {
             GroupManagementDAOFactory.closeConnection();
+            if(requireDeviceProps){
+                DeviceManagementDAOFactory.closeConnection();
+            }
         }
         return devices;
     }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/TestDeviceManager.java

@@ -61,8 +61,7 @@ public class TestDeviceManager implements DeviceManager {
     }
 
     @Override
-    public boolean deleteDevice(DeviceIdentifier deviceId, Device device) throws DeviceManagementException {
+    public void deleteDevices(List<String> deviceIdentifiers) throws DeviceManagementException {
-        return true;
     }
 
     @Override

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

@@ -138,7 +138,7 @@ public class GroupManagementProviderServiceNegativeTest extends BaseDeviceManage
     @Test(description = "This method tests the getDevices method under negative circumstances", expectedExceptions =
             {GroupManagementException.class})
     public void testGetDevicesWithPagination() throws GroupManagementException {
-        groupManagementProviderService.getDevices(1, 0, 10);
+        groupManagementProviderService.getDevices(1, 0, 10, false);
     }
 
     @Test(description = "This method tests the getGroupCount with username when the user name is given as null",

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

@@ -225,7 +225,7 @@ public class GroupManagementProviderServiceTest extends BaseDeviceManagementTest
 
     @Test(dependsOnMethods = ("createGroup"))
     public void getDevices() throws GroupManagementException {
-        List<Device> devices = groupManagementProviderService.getDevices(1, 1, 50);
+        List<Device> devices = groupManagementProviderService.getDevices(1, 1, 50, false);
         Assert.assertNotNull(devices);
     }
 

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/DeviceTypeManager.java

@@ -587,31 +587,36 @@ public class DeviceTypeManager implements DeviceManager {
     }
 
     @Override
-    public boolean deleteDevice(DeviceIdentifier deviceIdentifier, Device device) throws DeviceManagementException {
+    public void deleteDevices(List<String> deviceIdentifierList) throws DeviceManagementException {
         if (propertiesExist) {
-            boolean status;
-            Device existingDevice = this.getDevice(deviceIdentifier);
-            if (existingDevice == null) {
-                return false;
-            }
             try {
                 if (log.isDebugEnabled()) {
-                    log.debug("Deleting the details of " + deviceType + " device : " + device.getDeviceIdentifier());
+                    log.debug("Deleting the details of " + deviceType + " devices : " + deviceIdentifierList);
                 }
                 deviceTypePluginDAOManager.getDeviceTypeDAOHandler().beginTransaction();
-                status = deviceTypePluginDAOManager.getDeviceDAO().deleteDevice(existingDevice);
+                if (deviceTypePluginDAOManager.getDeviceDAO().deleteDevices(deviceIdentifierList)) {
                     deviceTypePluginDAOManager.getDeviceTypeDAOHandler().commitTransaction();
+                } else {
+                    deviceTypePluginDAOManager.getDeviceTypeDAOHandler().rollbackTransaction();
+                    String msg = "Error occurred while deleting the " + deviceType + " devices: '" +
+                            deviceIdentifierList;
+                    log.error(msg);
+                    throw new DeviceManagementException(msg);
+                }
             } catch (DeviceTypeMgtPluginException e) {
                 deviceTypePluginDAOManager.getDeviceTypeDAOHandler().rollbackTransaction();
-                throw new DeviceManagementException(
+                if (log.isDebugEnabled()) {
-                        "Error occurred while deleting the " + deviceType + " device: '" +
+                    log.debug("Error occurred while deleting the " + deviceType + " devices: '" +
-                        device.getDeviceIdentifier() + "'", e);
+                            deviceIdentifierList + "'. Transaction rolled back");
+                }
+                String msg= "Error occurred while deleting the " + deviceType + " devices: '" +
+                        deviceIdentifierList;
+                log.error(msg,e);
+                throw new DeviceManagementException(msg, e);
             } finally {
                 deviceTypePluginDAOManager.getDeviceTypeDAOHandler().closeConnection();
             }
-            return status;
         }
-        return true;
     }
 
 }

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/dao/DeviceTypePluginDAOImpl.java

@@ -39,6 +39,7 @@ import org.apache.commons.lang.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.wso2.carbon.device.mgt.common.Device;
+import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.exception.DeviceTypeMgtPluginException;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.util.DeviceTypeUtils;
 
@@ -46,6 +47,7 @@ import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -215,30 +217,39 @@ public class DeviceTypePluginDAOImpl implements PluginDAO {
     }
 
     @Override
-    public boolean deleteDevice(Device device) throws DeviceTypeMgtPluginException {
+    public boolean deleteDevices(List<String> deviceIdentifiers) throws DeviceTypeMgtPluginException {
-        boolean status = false;
-        Connection conn;
-        PreparedStatement stmt = null;
         try {
-            conn = deviceTypeDAOHandler.getConnection();
+            Connection conn = deviceTypeDAOHandler.getConnection();
-            stmt = conn.prepareStatement(deleteDBQueryForDeleteDevice);
+            boolean status = true;
-            stmt.setString(1, device.getDeviceIdentifier());
+            try (PreparedStatement ps = conn.prepareStatement(deleteDBQueryForDeleteDevice)) {
-            int rows = stmt.executeUpdate();
+                if (conn.getMetaData().supportsBatchUpdates()) {
-            if (rows > 0) {
+                    for (String deviceId : deviceIdentifiers) {
-                status = true;
+                        ps.setString(1, deviceId);
-                if (log.isDebugEnabled()) {
+                        ps.addBatch();
-                    log.debug("Device " + device.getDeviceIdentifier() + " data has been deleted.");
+                    }
+                    for (int i : ps.executeBatch()) {
+                        if (i == 0 || i == Statement.SUCCESS_NO_INFO || i == Statement.EXECUTE_FAILED) {
+                            status = false;
+                            break;
                         }
                     }
+                } else {
+                    for (String deviceId : deviceIdentifiers) {
+                        ps.setString(1, deviceId);
+                        if (ps.executeUpdate() == 0) {
+                            status = false;
+                            break;
+                        }
+                    }
+                }
+            }
+            return status;
         } catch (SQLException e) {
-            String msg = "Error occurred while deleting the device '" + device.getDeviceIdentifier() + "' data in "
+            String msg = "Error occurred while deleting the data in "
                     + deviceDAODefinition.getDeviceTableName();
             log.error(msg, e);
             throw new DeviceTypeMgtPluginException(msg, e);
-        } finally {
-            DeviceTypeUtils.cleanupResources(stmt, null);
         }
-        return status;
     }
 
     private String getDeviceTableColumnNames() {

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/dao/PluginDAO.java

@@ -50,5 +50,5 @@ public interface PluginDAO {
 
     List<Device> getAllDevices() throws DeviceTypeMgtPluginException;
 
-    boolean deleteDevice(Device device) throws DeviceTypeMgtPluginException;
+    boolean deleteDevices(List<String> deviceIdentifiers) throws DeviceTypeMgtPluginException;
 }

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/dao/PropertyBasedPluginDAOImpl.java

@@ -46,6 +46,7 @@ import org.wso2.carbon.device.mgt.extensions.device.type.template.util.DeviceTyp
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
+import java.sql.Statement;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -218,22 +219,38 @@ public class PropertyBasedPluginDAOImpl implements PluginDAO {
     }
 
     @Override
-    public boolean deleteDevice(Device device) throws DeviceTypeMgtPluginException {
+    public boolean deleteDevices(List<String> deviceIdentifiers) throws DeviceTypeMgtPluginException {
-        Connection conn;
-        PreparedStatement stmt = null;
         try {
-            conn = deviceTypeDAOHandler.getConnection();
+            Connection conn = deviceTypeDAOHandler.getConnection();
-            stmt = conn.prepareStatement("DELETE FROM DM_DEVICE_PROPERTIES WHERE DEVICE_IDENTIFICATION = ?");
+            boolean status = true;
-            stmt.setString(1, device.getDeviceIdentifier());
+            try (PreparedStatement ps = conn.prepareStatement("DELETE FROM DM_DEVICE_PROPERTIES WHERE DEVICE_IDENTIFICATION = ?")) {
-            stmt.executeUpdate();
+                if (conn.getMetaData().supportsBatchUpdates()) {
-            return true;
+                    for (String deviceId : deviceIdentifiers) {
+                        ps.setString(1, deviceId);
+                        ps.addBatch();
+                    }
+                    for (int i : ps.executeBatch()) {
+                        if (i == 0 || i == Statement.SUCCESS_NO_INFO || i == Statement.EXECUTE_FAILED) {
+                            status = false;
+                            break;
+                        }
+                    }
+                } else {
+                    for (String deviceId : deviceIdentifiers) {
+                        ps.setString(1, deviceId);
+                        if (ps.executeUpdate() == 0) {
+                            status = false;
+                            break;
+                        }
+                    }
+                }
+            }
+            return status;
         } catch (SQLException e) {
-            String msg = "Error occurred while deleting the device '" + device.getDeviceIdentifier() + "' data on"
+            String msg = "Error occurred while deleting the data of the devices: '" + deviceIdentifiers + "'of type:  "
                     + deviceType;
             log.error(msg, e);
             throw new DeviceTypeMgtPluginException(msg, e);
-        } finally {
-            DeviceTypeUtils.cleanupResources(stmt, null);
         }
     }
 

components/policy-mgt/org.wso2.carbon.policy.mgt.core/src/test/java/org/wso2/carbon/policy/mgt/core/mock/TypeXDeviceManager.java

@@ -79,8 +79,7 @@ public class TypeXDeviceManager implements DeviceManager {
     }
 
     @Override
-    public boolean deleteDevice(DeviceIdentifier deviceId, Device device) throws DeviceManagementException {
+    public void deleteDevices(List<String> deviceIdentifiers) throws DeviceManagementException {
-        return false;
     }
 
     @Override

components/ui-request-interceptor/io.entgra.ui.request.interceptor/src/main/java/io/entgra/ui/request/interceptor/LoginHandler.java

@@ -38,8 +38,6 @@ import org.apache.http.entity.ContentType;
 import org.apache.http.entity.StringEntity;
 import org.apache.http.protocol.HTTP;
 import org.wso2.carbon.device.application.mgt.common.ProxyResponse;
-import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
-import org.wso2.carbon.device.mgt.core.config.DeviceManagementConfig;
 
 import javax.servlet.annotation.MultipartConfig;
 import javax.servlet.annotation.WebServlet;
@@ -66,11 +64,6 @@ public class LoginHandler extends HttpServlet {
     protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
         try {
             validateLoginRequest(req, resp);
-            DeviceManagementConfig deviceManagementConfig = DeviceConfigurationManager.getInstance()
-                    .getDeviceManagementConfig();
-            String adminUsername = deviceManagementConfig.getIdentityConfigurations().getAdminUsername();
-            String adminPwd = deviceManagementConfig.getIdentityConfigurations().getAdminPassword();
-
             HttpSession httpSession = req.getSession(false);
             if (httpSession != null) {
                 httpSession.invalidate();
@@ -120,7 +113,7 @@ public class LoginHandler extends HttpServlet {
                 // default login
                 HttpPost apiRegEndpoint = new HttpPost(serverUrl + HandlerConstants.APP_REG_ENDPOINT);
                 apiRegEndpoint.setHeader(HttpHeaders.AUTHORIZATION, HandlerConstants.BASIC + Base64.getEncoder()
-                        .encodeToString((adminUsername + HandlerConstants.COLON + adminPwd).getBytes()));
+                        .encodeToString((username + HandlerConstants.COLON + password).getBytes()));
                 apiRegEndpoint.setHeader(HTTP.CONTENT_TYPE, ContentType.APPLICATION_JSON.toString());
                 apiRegEndpoint.setEntity(constructAppRegPayload(tags));