kavindya_devindi
/
device-mgt-core
forked from community/device-mgt-core
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Modify permanent delete API to support list of devices

Browse Source
3.x.x
Amanda Randombage 5 years ago committed by Saad Sahibjan
parent 5c2af197d3
commit ff2c038688
11 changed files with 487 additions and 419 deletions
Show Stats Download Patch File Download Diff File

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

@ -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(
@ApiParam(
name = "device-type",
value = "The device type, such as ios, android, or windows.",
required = true)
@PathParam("device-type")
@Size(max = 45)
String deviceType,
Response deleteDevicesPermanently(
@ApiParam(
name = "device-id",
value = "The device identifier of the device.",
name = "Device Identifiers",
value = "List of device identifiers.",
required = true)
@PathParam("device-id")
@Size(max = 45)
String deviceId);
List<String> deviceIdentifiers);
}

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

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

8
components/device-mgt/org.wso2.carbon.device.mgt.common/src/main/java/org/wso2/carbon/device/mgt/common/DeviceManager.java
Unescape View File

@ -97,13 +97,11 @@ public interface DeviceManager {
boolean disenrollDevice(DeviceIdentifier deviceId) throws DeviceManagementException;
/**
* Method to delete a particular device from CDM.
*
* @param deviceId Fully qualified device identifier
* @return A boolean indicating the status of the operation.
* Method to delete multiple devices from CDM.
* @param deviceIdentifiers Fully qualified device identifier list
* @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.

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

@ -522,11 +522,12 @@ 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
* @param deviceIdentifier device id
* @param tenantId tenant id
* @throws DeviceManagementDAOException
/***
* This method is used to permanently delete devices and their related details
* @param deviceIdentifiers List of device identifiers.
* @param deviceIds list of device ids (primary keys).
* @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;
}

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

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

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

@ -597,7 +597,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;

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

@ -99,6 +99,7 @@ import org.wso2.carbon.device.mgt.common.push.notification.NotificationStrategy;
import org.wso2.carbon.device.mgt.common.spi.DeviceManagementService;
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;
@ -142,6 +143,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;
@ -519,72 +521,90 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
}
@Override
public boolean deleteDevice(DeviceIdentifier deviceId) throws DeviceManagementException {
if (deviceId == null) {
String msg = "Required values are not set to permanently delete device";
public boolean deleteDevices(List<String> deviceIdentifiers) throws DeviceManagementException, InvalidDeviceException {
List<Integer> deviceIds = new ArrayList<>();
List<Integer> enrollmentIds = new ArrayList<>();
Map<String, List<String>> deviceIdentifierMap = new HashMap<>();
Map<String, DeviceManager> deviceManagerMap = new HashMap<>();
List<DeviceCacheKey> deviceCacheKeyList = new ArrayList<>();
int tenantId = this.getTenantId();
List<Device> existingDevices;
try {
DeviceManagementDAOFactory.beginTransaction();
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);
throw new DeviceManagementException(msg);
DeviceManagementDAOFactory.rollbackTransaction();
throw new InvalidDeviceException(msg);
}
if (log.isDebugEnabled()) {
log.debug("Permanently deleting device: " + deviceId.getId() + " of type '" + deviceId.getType() + "'");
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);
}
DeviceManager deviceManager = this.getDeviceManager(deviceId.getType());
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 '" + deviceId.getType() + "' is null. " +
"Therefore, not attempting method 'deleteDevice'");
log.debug("Device Manager associated with the device type '"
+ device.getType() + "' is null. Therefore, not attempting method 'deleteDevice'");
}
return false;
}
int tenantId = this.getTenantId();
Device device = this.getDevice(deviceId, false);
if (device == null) {
if (log.isDebugEnabled()) {
log.debug("Device not found for id '" + deviceId.getId() + "'");
deviceManagerMap.put(device.getType(), deviceManager);
}
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 {
//deleting device from the core
deviceDAO.deleteDevices(deviceIdentifiers, deviceIds, enrollmentIds);
for (Map.Entry<String, DeviceManager> entry : deviceManagerMap.entrySet()) {
try {
DeviceManagementDAOFactory.beginTransaction();
deviceDAO.deleteDevice(deviceId, tenantId);
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() +
"' device with the identifier '" + deviceId.getId() + "' in plugin.";
String msg = "Error occurred while permanently deleting '" + entry.getKey() +
"' 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);
} catch (DeviceManagementDAOException e) {
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);
this.removeDevicesFromCache(deviceCacheKeyList);
return true;
} catch (TransactionManagementException e) {
String msg = "Error occurred while initiating transaction";
log.error(msg, e);
throw new DeviceManagementException(msg, e);
} catch (Exception e) {
String msg = "Error occurred while permanently deleting device: " + deviceId.getId();
} catch (DeviceManagementDAOException e) {
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
@ -2976,6 +2996,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 {

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

@ -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(
"Error occurred while deleting the " + deviceType + " device: '" +
device.getDeviceIdentifier() + "'", e);
if (log.isDebugEnabled()) {
log.debug("Error occurred while deleting the " + deviceType + " devices: '" +
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;
}
}

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

@ -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 {
boolean status = false;
Connection conn;
PreparedStatement stmt = null;
public boolean deleteDevices(List<String> deviceIdentifiers) throws DeviceTypeMgtPluginException {
try {
conn = deviceTypeDAOHandler.getConnection();
stmt = conn.prepareStatement(deleteDBQueryForDeleteDevice);
stmt.setString(1, device.getDeviceIdentifier());
int rows = stmt.executeUpdate();
if (rows > 0) {
status = true;
if (log.isDebugEnabled()) {
log.debug("Device " + device.getDeviceIdentifier() + " data has been deleted.");
Connection conn = deviceTypeDAOHandler.getConnection();
boolean status = true;
try (PreparedStatement ps = conn.prepareStatement(deleteDBQueryForDeleteDevice)) {
if (conn.getMetaData().supportsBatchUpdates()) {
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 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() {

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

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

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

@ -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 {
Connection conn;
PreparedStatement stmt = null;
public boolean deleteDevices(List<String> deviceIdentifiers) throws DeviceTypeMgtPluginException {
try {
conn = deviceTypeDAOHandler.getConnection();
stmt = conn.prepareStatement("DELETE FROM DM_DEVICE_PROPERTIES WHERE DEVICE_IDENTIFICATION = ?");
stmt.setString(1, device.getDeviceIdentifier());
stmt.executeUpdate();
return true;
Connection conn = deviceTypeDAOHandler.getConnection();
boolean status = true;
try (PreparedStatement ps = conn.prepareStatement("DELETE FROM DM_DEVICE_PROPERTIES WHERE DEVICE_IDENTIFICATION = ?")) {
if (conn.getMetaData().supportsBatchUpdates()) {
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);
}
}

Write Preview
Loading…
Cancel
Save