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

Merge branch 'application-mgt-new' into 'application-mgt-new'

Browse Source 
Sync with master & fixes

See merge request entgra/carbon-device-mgt!258
feature/appm-store/pbac
Dharmakeerthi Lasantha 5 years ago
parent d9999ad5b2 20bbb6b91a
commit 8e9d64038b
30 changed files with 884 additions and 472 deletions
Show Stats Download Patch File Download Diff File

93
components/device-mgt/io.entgra.carbon.device.mgt.config.api/src/main/java/io/entgra/carbon/device/mgt/config/jaxrs/service/DeviceManagementConfigService.java
Unescape View File

@ -18,6 +18,7 @@
package io.entgra.carbon.device.mgt.config.jaxrs.service; package io.entgra.carbon.device.mgt.config.jaxrs.service;
import org.wso2.carbon.device.mgt.common.DeviceTransferRequest;
import io.entgra.carbon.device.mgt.config.jaxrs.beans.ErrorResponse; import io.entgra.carbon.device.mgt.config.jaxrs.beans.ErrorResponse;
import io.swagger.annotations.Api; import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
@ -33,12 +34,11 @@ import io.swagger.annotations.Tag;
import org.wso2.carbon.apimgt.annotations.api.Scope; import org.wso2.carbon.apimgt.annotations.api.Scope;
import org.wso2.carbon.apimgt.annotations.api.Scopes; import org.wso2.carbon.apimgt.annotations.api.Scopes;
import org.wso2.carbon.device.mgt.common.configuration.mgt.DeviceConfiguration; import org.wso2.carbon.device.mgt.common.configuration.mgt.DeviceConfiguration;
import org.wso2.carbon.device.mgt.common.search.PropertyMap;
import javax.ws.rs.Consumes; import javax.ws.rs.Consumes;
import javax.ws.rs.GET; import javax.ws.rs.GET;
import javax.ws.rs.HeaderParam; import javax.ws.rs.HeaderParam;
import javax.ws.rs.POST; import javax.ws.rs.PUT;
import javax.ws.rs.Path; import javax.ws.rs.Path;
import javax.ws.rs.Produces; import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam; import javax.ws.rs.QueryParam;
@ -63,7 +63,6 @@ import javax.ws.rs.core.Response;
) )
@Path("/configurations") @Path("/configurations")
@Api(value = "Device Management Configuration") @Api(value = "Device Management Configuration")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON)
@Scopes(scopes = { @Scopes(scopes = {
@Scope( @Scope(
@ -71,6 +70,12 @@ import javax.ws.rs.core.Response;
description = "", description = "",
key = "perm:view-configuration", key = "perm:view-configuration",
permissions = {"/device-mgt/platform-configurations/view"} permissions = {"/device-mgt/platform-configurations/view"}
),
@Scope(
name = "Manage configurations",
description = "",
key = "perm:manage-configuration",
permissions = {"/device-mgt/platform-configurations/manage"}
) )
} }
) )
@ -119,16 +124,74 @@ public interface DeviceManagementConfigService {
"fetching device configurations.", "fetching device configurations.",
response = ErrorResponse.class) response = ErrorResponse.class)
}) })
Response getConfiguration(@ApiParam( @Produces(MediaType.APPLICATION_JSON)
name = "token", Response getConfiguration(
value = "value for identify an already enrolled and authorized device", @ApiParam(
required = true) name = "token",
@HeaderParam("token") value = "value for identify an already enrolled and authorized device",
String token, required = true)
@ApiParam( @HeaderParam("token")
name = "properties", String token,
value = "The properties list using for query a device", @ApiParam(
required = true) name = "properties",
@QueryParam("properties") value = "The properties list using for query a device",
String properties); required = true)
@QueryParam("properties")
String properties);
@PUT
@Path("/transfer")
@ApiOperation(
produces = MediaType.APPLICATION_JSON,
httpMethod = "PUT",
value = "Transfer device to another tenant from super tenant",
notes = "This API is responsible for transfer device from super tenant to another tenant",
tags = "Device Management Configuration",
extensions = {
@Extension(properties = {
@ExtensionProperty(name = "scope", value = "perm:manage-configuration")
})
}
)
@ApiResponses(
value = {
@ApiResponse(
code = 200,
message = "OK. \n Successfully transferred the device.",
response = DeviceConfiguration.class,
responseContainer = "List",
responseHeaders = {
@ResponseHeader(
name = "Content-Type",
description = "The content type of the body"),
@ResponseHeader(
name = "ETag",
description = "Entity Tag of the response resource.\n" +
"Used by caches, or in conditional requests."),
@ResponseHeader(
name = "Last-Modified",
description = "Date and time the resource has been modified " +
"the last time.Used by caches, or in " +
"conditional requests."),
}
),
@ApiResponse(
code = 400,
message = "Bad request.\n The request contains invalid parameters"),
@ApiResponse(
code = 401,
message = "Unauthorized.\n The requested is not authorized"),
@ApiResponse(
code = 500,
message = "Internal Server Error. \n Server error occurred while " +
"fetching device configurations.",
response = ErrorResponse.class)
})
@Produces(MediaType.APPLICATION_JSON)
Response transferDevices(
@ApiParam(
name = "Device Transfer Request",
value = "The device transfer request",
required = true)
DeviceTransferRequest deviceTransferRequest);
} }

41
components/device-mgt/io.entgra.carbon.device.mgt.config.api/src/main/java/io/entgra/carbon/device/mgt/config/jaxrs/service/impl/DeviceManagementConfigServiceImpl.java
Unescape View File

@ -26,8 +26,10 @@ import io.entgra.carbon.device.mgt.config.jaxrs.service.DeviceManagementConfigSe
import io.entgra.carbon.device.mgt.config.jaxrs.util.DeviceMgtAPIUtils; import io.entgra.carbon.device.mgt.config.jaxrs.util.DeviceMgtAPIUtils;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.common.AppRegistrationCredentials; import org.wso2.carbon.device.mgt.common.AppRegistrationCredentials;
import org.wso2.carbon.device.mgt.common.ApplicationRegistrationException; import org.wso2.carbon.device.mgt.common.ApplicationRegistrationException;
import org.wso2.carbon.device.mgt.common.DeviceTransferRequest;
import org.wso2.carbon.device.mgt.common.configuration.mgt.AmbiguousConfigurationException; import org.wso2.carbon.device.mgt.common.configuration.mgt.AmbiguousConfigurationException;
import org.wso2.carbon.device.mgt.common.configuration.mgt.DeviceConfiguration; import org.wso2.carbon.device.mgt.common.configuration.mgt.DeviceConfiguration;
import org.wso2.carbon.device.mgt.common.exceptions.DeviceManagementException; import org.wso2.carbon.device.mgt.common.exceptions.DeviceManagementException;
@ -41,16 +43,17 @@ import org.wso2.carbon.identity.jwt.client.extension.exception.JWTClientExceptio
import javax.ws.rs.Consumes; import javax.ws.rs.Consumes;
import javax.ws.rs.GET; import javax.ws.rs.GET;
import javax.ws.rs.HeaderParam; import javax.ws.rs.HeaderParam;
import javax.ws.rs.PUT;
import javax.ws.rs.Path; import javax.ws.rs.Path;
import javax.ws.rs.Produces; import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam; import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType; import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response; import javax.ws.rs.core.Response;
import java.io.IOException; import java.io.IOException;
import java.util.List;
import java.util.Map; import java.util.Map;
@Path("/configurations") @Path("/configurations")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON)
public class DeviceManagementConfigServiceImpl implements DeviceManagementConfigService { public class DeviceManagementConfigServiceImpl implements DeviceManagementConfigService {
@ -58,6 +61,7 @@ public class DeviceManagementConfigServiceImpl implements DeviceManagementConfig
@Override @Override
@GET @GET
@Produces(MediaType.APPLICATION_JSON)
public Response getConfiguration(@HeaderParam("token") String token, public Response getConfiguration(@HeaderParam("token") String token,
@QueryParam("properties") String properties) { @QueryParam("properties") String properties) {
DeviceManagementProviderService dms = DeviceMgtAPIUtils.getDeviceManagementService(); DeviceManagementProviderService dms = DeviceMgtAPIUtils.getDeviceManagementService();
@ -115,6 +119,41 @@ public class DeviceManagementConfigServiceImpl implements DeviceManagementConfig
} }
} }
@PUT
@Path("/transfer")
@Override
@Produces(MediaType.APPLICATION_JSON)
public Response transferDevices(DeviceTransferRequest deviceTransferRequest) {
PrivilegedCarbonContext ctx = PrivilegedCarbonContext.getThreadLocalCarbonContext();
int tenantId = ctx.getTenantId(false);
if (tenantId != -1234) {
return Response.status(Response.Status.FORBIDDEN).entity("Tenant '" + ctx.getTenantDomain(true) +
"' does not have privilege to transfer device").build();
}
DeviceManagementProviderService dms = DeviceMgtAPIUtils.getDeviceManagementService();
try {
List<String> devicesTransferred = dms.transferDeviceToTenant(deviceTransferRequest);
if (devicesTransferred.isEmpty()) {
String msg = "Devices are not enrolled to super tenant";
log.warn(msg);
return Response.status(Response.Status.BAD_REQUEST).entity(
new ErrorResponse.ErrorResponseBuilder().setMessage(msg).build()).build();
} else {
return Response.status(Response.Status.OK).entity(devicesTransferred).build();
}
} catch (DeviceManagementException e) {
String msg = "Error occurred while transferring device to tenant " +
deviceTransferRequest.getDestinationTenant();
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(
new ErrorResponse.ErrorResponseBuilder().setMessage(msg).build()).build();
} catch (DeviceNotFoundException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.BAD_REQUEST).entity(
new ErrorResponse.ErrorResponseBuilder().setMessage(e.getMessage()).build()).build();
}
}
private String parseUriParamsToJSON(String uriParams) { private String parseUriParamsToJSON(String uriParams) {
uriParams = uriParams.replaceAll("=", "\":\""); uriParams = uriParams.replaceAll("=", "\":\"");
uriParams = uriParams.replaceAll("&", "\",\""); uriParams = uriParams.replaceAll("&", "\",\"");

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

@ -681,7 +681,15 @@ public interface GroupManagementService {
"pagination index/offset.", "pagination index/offset.",
defaultValue = "5") defaultValue = "5")
@QueryParam("limit") @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") @Path("/id/{groupId}/devices/count")
@GET @GET

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

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

@ -652,10 +652,19 @@ public class DeviceManagementServiceImpl implements DeviceManagementService {
List<Device> devices; List<Device> devices;
DeviceList deviceList = new DeviceList(); DeviceList deviceList = new DeviceList();
try { 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(); DeviceManagementProviderService dms = DeviceMgtAPIUtils.getDeviceManagementService();
devices = dms.getDevicesBasedOnProperties(map.getProperties()); devices = dms.getDevicesBasedOnProperties(map.getProperties());
if(devices == null || devices.isEmpty()){ 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) { } catch (DeviceManagementException e) {
String msg = "Error occurred while searching for devices that matches the provided device properties"; String msg = "Error occurred while searching for devices that matches the provided device properties";

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

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

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 @DELETE
@Override @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 = DeviceManagementProviderService deviceManagementProviderService =
DeviceMgtAPIUtils.getDeviceManagementService(); DeviceMgtAPIUtils.getDeviceManagementService();
try { 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); 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(); 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) { } 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); log.error(msg, e);
return Response.status(Response.Status.BAD_REQUEST).entity( return Response.status(Response.Status.BAD_REQUEST).entity(
new ErrorResponse.ErrorResponseBuilder().setMessage(msg).build()).build(); new ErrorResponse.ErrorResponseBuilder().setMessage(msg).build()).build();

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

@ -266,16 +266,16 @@ public class GroupManagementServiceImplTest {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getGroupManagementProviderService")) PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getGroupManagementProviderService"))
.toReturn(groupManagementProviderService); .toReturn(groupManagementProviderService);
Mockito.doReturn(1).when(groupManagementProviderService).getDeviceCount(Mockito.anyInt()); 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(), Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
"getDevicesOfGroup request failed for a request with valid parameters"); "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(), Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
"getDevicesOfGroup request failed for a request with valid parameters"); "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(), Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"getDevicesOfGroup request succeded for a request with in-valid parameters"); "getDevicesOfGroup request succeded for a request with in-valid parameters");
} }

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

@ -98,13 +98,11 @@ public interface DeviceManager {
boolean disenrollDevice(DeviceIdentifier deviceId) throws DeviceManagementException; 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 * @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. * Method to retrieve the status of the registration process of a particular device.

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

@ -0,0 +1,48 @@
package org.wso2.carbon.device.mgt.common;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.util.List;
/**
* Represents an individual configuration entry.
*/
@ApiModel(value = "DeviceTransferRequest", description = "This class carries all information related to device " +
"transfer from super tenant to another tenant.")
public class DeviceTransferRequest {
@ApiModelProperty(name = "deviceType", value = "Type of the device", required = true)
private String deviceType;
@ApiModelProperty(name = "deviceIds", value = "Ids of devices to transfer", required = true)
private List<String> deviceIds;
@ApiModelProperty(name = "destinationTenant", value = "Destination Tenant ID", required = true)
private String destinationTenant;
public String getDeviceType() {
return deviceType;
}
public void setDeviceType(String deviceType) {
this.deviceType = deviceType;
}
public List<String> getDeviceIds() {
return deviceIds;
}
public void setDeviceId(List<String> deviceIds) {
this.deviceIds = deviceIds;
}
public String getDestinationTenant() {
return destinationTenant;
}
public void setDestinationTenant(String destinationTenant) {
this.destinationTenant = destinationTenant;
}
}

4
components/device-mgt/org.wso2.carbon.device.mgt.core/pom.xml
Unescape View File

@ -356,6 +356,10 @@
<groupId>org.powermock</groupId> <groupId>org.powermock</groupId>
<artifactId>powermock-api-mockito</artifactId> <artifactId>powermock-api-mockito</artifactId>
</dependency> </dependency>
<dependency>
<groupId>org.wso2.carbon.multitenancy</groupId>
<artifactId>org.wso2.carbon.tenant.mgt</artifactId>
</dependency>
</dependencies> </dependencies>
</project> </project>

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

@ -45,6 +45,7 @@ import org.wso2.carbon.device.mgt.core.dto.DeviceType;
import org.wso2.carbon.device.mgt.core.geo.GeoCluster; import org.wso2.carbon.device.mgt.core.geo.GeoCluster;
import org.wso2.carbon.device.mgt.core.geo.geoHash.GeoCoordinate; import org.wso2.carbon.device.mgt.core.geo.geoHash.GeoCoordinate;
import java.sql.SQLException;
import java.util.Date; import java.util.Date;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
@ -522,11 +523,15 @@ public interface DeviceDAO {
List<Device> getDevicesByIdentifiers(List<String> deviceIdentifiers, int tenantId) List<Device> getDevicesByIdentifiers(List<String> deviceIdentifiers, int tenantId)
throws DeviceManagementDAOException; 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;
} }

596
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.ResultSet;
import java.sql.SQLException; import java.sql.SQLException;
import java.sql.Timestamp; import java.sql.Timestamp;
import java.sql.Statement;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
import java.util.Date; import java.util.Date;
@ -1560,9 +1561,8 @@ public abstract class AbstractDeviceDAOImpl implements DeviceDAO {
ps.setInt(index++, tenantId); ps.setInt(index++, tenantId);
ps.setInt(index, tenantId); ps.setInt(index, tenantId);
try (ResultSet rs = ps.executeQuery()) { try (ResultSet rs = ps.executeQuery()) {
if (rs.next()) { while (rs.next()) {
Device device = DeviceManagementDAOUtil.loadDevice(rs); devices.add(DeviceManagementDAOUtil.loadDevice(rs));
devices.add(device);
} }
} }
} }
@ -1572,369 +1572,461 @@ public abstract class AbstractDeviceDAOImpl implements DeviceDAO {
+ " given device identifiers.", e); + " given device identifiers.", e);
} }
} }
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; Connection conn;
try { try {
conn = this.getConnection(); 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); log.error(msg);
throw new DeviceManagementDAOException(msg); throw new DeviceManagementDAOException(msg);
} else { } else {
List<Integer> enrollmentIds = getEnrollmentIds(conn, deviceId, tenantId); removeDeviceDetail(conn, deviceIds);
if (enrollmentIds == null || enrollmentIds.isEmpty()) { if (log.isDebugEnabled()) {
String msg = "Enrollments not found for the device " + deviceIdentifierId + " of type " log.debug("Successfully removed device detail data of devices: " + deviceIdentifiers);
+ deviceType; }
log.error(msg); removeDeviceLocation(conn, deviceIds);
throw new DeviceManagementDAOException(msg); if (log.isDebugEnabled()) {
} else { log.debug("Successfully removed device location data of devices: " + deviceIdentifiers);
removeDeviceDetail(conn, deviceId); }
if (log.isDebugEnabled()) { removeDeviceInfo(conn, deviceIds);
log.debug("Successfully removed device detail data of device " + deviceIdentifierId if (log.isDebugEnabled()) {
+ " of type " + deviceType); log.debug("Successfully removed device info data of devices: " + deviceIdentifiers);
} }
removeDeviceLocation(conn, deviceId); removeDeviceNotification(conn, deviceIds);
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Successfully removed device location data of device " + deviceIdentifierId log.debug("Successfully removed device notification data of devices: " + deviceIdentifiers);
+ " of type " + deviceType); }
} removeDeviceApplicationMapping(conn, deviceIds);
removeDeviceInfo(conn, deviceId); if (log.isDebugEnabled()) {
if (log.isDebugEnabled()) { log.debug("Successfully removed device application mapping data of devices: "
log.debug("Successfully removed device info data of device " + deviceIdentifierId + deviceIdentifiers);
+ " of type " + deviceType); }
} removeDevicePolicyApplied(conn, deviceIds);
removeDeviceNotification(conn, deviceId); if (log.isDebugEnabled()) {
if (log.isDebugEnabled()) { log.debug("Successfully removed device applied policy data of devices: " + deviceIdentifiers);
log.debug("Successfully removed device notification data of device " + deviceIdentifierId }
+ " of type " + deviceType); removeDevicePolicy(conn, deviceIds);
} if (log.isDebugEnabled()) {
removeDeviceApplicationMapping(conn, deviceId); log.debug("Successfully removed device policy data of devices: " + deviceIdentifiers);
if (log.isDebugEnabled()) { }
log.debug("Successfully removed device application mapping data of device " if (log.isDebugEnabled()) {
+ deviceIdentifierId + " of type " + deviceType); log.debug("Starting to remove " + enrollmentIds.size() + " enrollment data of devices with " +
} "identifiers: " + deviceIdentifiers);
removeDevicePolicyApplied(conn, deviceId); }
if (log.isDebugEnabled()) { removeEnrollmentDeviceDetail(conn, enrollmentIds);
log.debug("Successfully removed device applied policy data of device " + deviceIdentifierId removeEnrollmentDeviceLocation(conn, enrollmentIds);
+ " of type " + deviceType); removeEnrollmentDeviceInfo(conn, enrollmentIds);
} removeEnrollmentDeviceApplicationMapping(conn, enrollmentIds);
removeDevicePolicy(conn, deviceId); removeDeviceOperationResponse(conn, enrollmentIds);
if (log.isDebugEnabled()) { removeEnrollmentOperationMapping(conn, enrollmentIds);
log.debug("Successfully removed device policy data of device " + deviceIdentifierId if (log.isDebugEnabled()) {
+ " of type " + deviceType); log.debug("Successfully removed enrollment device details, enrollment device location," +
} "enrollment device info, enrollment device application mapping, " +
if (log.isDebugEnabled()) { "enrollment device operation response, enrollment operation mapping data of " +
log.debug("Starting to remove " + enrollmentIds.size() + " enrollment data of device " "devices with identifiers: " + deviceIdentifiers);
+ deviceIdentifierId + " of type " + deviceType); }
} removeDeviceEnrollment(conn, deviceIds);
for (Integer enrollmentId : enrollmentIds) { if (log.isDebugEnabled()) {
removeEnrollmentDeviceDetail(conn, enrollmentId); log.debug("Successfully removed device enrollment data of devices: " + deviceIdentifiers);
removeEnrollmentDeviceLocation(conn, enrollmentId); }
removeEnrollmentDeviceInfo(conn, enrollmentId); removeDeviceGroupMapping(conn, deviceIds);
removeEnrollmentDeviceApplicationMapping(conn, enrollmentId); if (log.isDebugEnabled()) {
removeDeviceOperationResponse(conn, enrollmentId); log.debug("Successfully removed device group mapping data of devices: " + deviceIdentifiers);
removeEnrollmentOperationMapping(conn, enrollmentId); }
} removeDevice(conn, deviceIds);
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Successfully removed enrollment device details, enrollment device location, " + log.debug("Successfully permanently deleted the device of devices: " + deviceIdentifiers);
"enrollment device info, enrollment device application mapping, " +
"enrollment device operation response, enrollment operation mapping data of device "
+ deviceIdentifierId + " of type " + deviceType);
}
removeDeviceEnrollment(conn, deviceId);
if (log.isDebugEnabled()) {
log.debug("Successfully removed device enrollment data of device " + deviceIdentifierId
+ " of type " + deviceType);
}
removeDeviceGroupMapping(conn, deviceId);
if (log.isDebugEnabled()) {
log.debug("Successfully removed device group mapping data of device " + deviceIdentifierId
+ " of type " + deviceType);
}
removeDevice(conn, deviceId);
if (log.isDebugEnabled()) {
log.debug("Successfully permanently deleted the device of device " + deviceIdentifierId
+ " of type " + deviceType);
}
} }
} }
} catch (SQLException e) { } 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
*/
private void removeDeviceDetail(Connection conn, List<Integer> deviceIds) throws DeviceManagementDAOException {
String sql = "DELETE FROM DM_DEVICE_DETAIL WHERE DEVICE_ID = ?";
try { try {
String sql = "SELECT ID FROM DM_DEVICE WHERE DEVICE_IDENTIFICATION = ? AND TENANT_ID = ?"; executeBatchOperation(conn, sql, deviceIds);
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) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while retrieving device id of the device", e); String msg = "Error occurred while removing device details.";
} finally { log.error(msg, e);
DeviceManagementDAOUtil.cleanupResources(stmt, rs); throw new DeviceManagementDAOException(msg, e);
} }
return deviceId;
} }
private List<Integer> getEnrollmentIds(Connection conn, int deviceId, int tenantId) throws DeviceManagementDAOException { /***
PreparedStatement stmt = null; * This method removes records of a given list of devices from the DM_DEVICE_LOCATION table
ResultSet rs = null; * @param conn Connection object
List<Integer> enrollmentIds = new ArrayList<>(); * @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 { try {
String sql = "SELECT ID FROM DM_ENROLMENT WHERE DEVICE_ID = ? AND TENANT_ID = ?"; executeBatchOperation(conn, sql, deviceIds);
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) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while retrieving enrollment id of the device", e); String msg = "Error occurred while obtaining locations of devices.";
} finally { log.error(msg, e);
DeviceManagementDAOUtil.cleanupResources(stmt, rs); 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 { try {
String sql = "DELETE FROM DM_DEVICE_DETAIL WHERE DEVICE_ID = ?"; executeBatchOperation(conn, sql, deviceIds);
stmt = conn.prepareStatement(sql);
stmt.setInt(1, deviceId);
stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing device detail", 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 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 { try {
String sql = "DELETE FROM DM_DEVICE_LOCATION WHERE DEVICE_ID = ?"; executeBatchOperation(conn, sql, deviceIds);
stmt = conn.prepareStatement(sql);
stmt.setInt(1, deviceId);
stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing device location", 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 removeDeviceInfo(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 { try {
String sql = "DELETE FROM DM_DEVICE_INFO WHERE DEVICE_ID = ?"; executeBatchOperation(conn, sql, deviceIds);
stmt = conn.prepareStatement(sql);
stmt.setInt(1, deviceId);
stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing device info", 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 removeDeviceNotification(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 { try {
String sql = "DELETE FROM DM_NOTIFICATION WHERE DEVICE_ID = ?"; executeBatchOperation(conn, sql, deviceIds);
stmt = conn.prepareStatement(sql);
stmt.setInt(1, deviceId);
stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing device notification", 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 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 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 { try {
String sql = "DELETE FROM DM_DEVICE_APPLICATION_MAPPING WHERE DEVICE_ID = ?"; executeBatchOperation(conn, sql, deviceIds);
stmt = conn.prepareStatement(sql);
stmt.setInt(1, deviceId);
stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing device application mapping", 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 removeDevicePolicyApplied(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 { try {
String sql = "DELETE FROM DM_DEVICE_POLICY_APPLIED WHERE DEVICE_ID = ?"; executeBatchOperation(conn, sql, enrollmentIds);
stmt = conn.prepareStatement(sql);
stmt.setInt(1, deviceId);
stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing device policy applied", 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 removeDevicePolicy(Connection conn, int deviceId) 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 { try {
String sql = "DELETE FROM DM_DEVICE_POLICY WHERE DEVICE_ID = ?"; executeBatchOperation(conn, sql, enrollmentIds);
stmt = conn.prepareStatement(sql);
stmt.setInt(1, deviceId);
stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing device policy", 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 removeEnrollmentDeviceDetail(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 { try {
String sql = "DELETE FROM DM_DEVICE_DETAIL WHERE ENROLMENT_ID = ?"; executeBatchOperation(conn, sql, enrollmentIds);
stmt = conn.prepareStatement(sql);
stmt.setInt(1, enrollmentId);
stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing enrollment device detail", 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 removeEnrollmentDeviceLocation(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 { try {
String sql = "DELETE FROM DM_DEVICE_LOCATION WHERE ENROLMENT_ID = ?"; executeBatchOperation(conn, sql, enrollmentIds);
stmt = conn.prepareStatement(sql);
stmt.setInt(1, enrollmentId);
stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing enrollment device location", 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 removeEnrollmentDeviceInfo(Connection conn, int enrollmentId) throws DeviceManagementDAOException { /***
PreparedStatement stmt = null; * 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 {
String sql = "DELETE FROM DM_DEVICE_OPERATION_RESPONSE WHERE ENROLMENT_ID = ?";
try { try {
String sql = "DELETE FROM DM_DEVICE_INFO WHERE ENROLMENT_ID = ?"; executeBatchOperation(conn, sql, enrollmentIds);
stmt = conn.prepareStatement(sql);
stmt.setInt(1, enrollmentId);
stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing enrollment device info", e); String msg = "Error occurred while removing device operation response";
} 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_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 { throws DeviceManagementDAOException {
PreparedStatement stmt = null; String sql = "DELETE FROM DM_ENROLMENT_OP_MAPPING WHERE ENROLMENT_ID = ?";
try { try {
String sql = "DELETE FROM DM_DEVICE_APPLICATION_MAPPING WHERE ENROLMENT_ID = ?"; executeBatchOperation(conn, sql, enrollmentIds);
stmt = conn.prepareStatement(sql);
stmt.setInt(1, enrollmentId);
stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing enrollment device application " + String msg = "Error occurred while removing enrollment operation mapping";
"mapping", e); log.error(msg, e);
} finally { throw new DeviceManagementDAOException(msg, e);
DeviceManagementDAOUtil.cleanupResources(stmt, null);
} }
} }
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 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 {
String sql = "DELETE FROM DM_ENROLMENT WHERE DEVICE_ID = ?";
try { 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) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing device operation response", e); String msg = "Error occurred while removing enrollments of devices";
} finally { log.error(msg, e);
DeviceManagementDAOUtil.cleanupResources(stmt, null); throw new DeviceManagementDAOException(msg, e);
}
}
/***
* 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 {
executeBatchOperation(conn, sql, deviceIds);
} catch (SQLException e) {
String msg = "Error occurred while removing device group mapping";
log.error(msg, e);
throw new DeviceManagementDAOException(msg, e);
}
}
/***
* 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 {
executeBatchOperation(conn, sql, deviceIds);
} catch (SQLException e) {
String msg = "Error occurred while removing devices.";
log.error(msg, e);
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;
}
}
}
} }
} }
private void removeEnrollmentOperationMapping(Connection conn, int enrollmentId) private int getDeviceId(Connection conn, DeviceIdentifier deviceIdentifier, int tenantId)
throws DeviceManagementDAOException { throws DeviceManagementDAOException {
PreparedStatement stmt = null; PreparedStatement stmt = null;
ResultSet rs = null;
int deviceId = -1;
try { try {
String sql = "DELETE FROM DM_ENROLMENT_OP_MAPPING WHERE ENROLMENT_ID = ?"; String sql = "SELECT ID FROM DM_DEVICE WHERE DEVICE_IDENTIFICATION = ? AND TENANT_ID = ?";
stmt = conn.prepareStatement(sql); stmt = conn.prepareStatement(sql);
stmt.setInt(1, enrollmentId); stmt.setString(1, deviceIdentifier.getId());
stmt.executeUpdate(); stmt.setInt(2, tenantId);
rs = stmt.executeQuery();
if (rs.next()) {
deviceId = rs.getInt("ID");
}
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing enrollment operation mapping", e); throw new DeviceManagementDAOException("Error occurred while retrieving device id of the device", e);
} finally { } finally {
DeviceManagementDAOUtil.cleanupResources(stmt, null); DeviceManagementDAOUtil.cleanupResources(stmt, rs);
} }
return deviceId;
} }
private void removeDeviceEnrollment(Connection conn, int deviceId) throws DeviceManagementDAOException { public boolean transferDevice(String deviceType, String deviceIdentifier, String owner, int destinationTenantId)
throws DeviceManagementDAOException, SQLException {
Connection conn = this.getConnection();
int deviceId = getDeviceId(conn, new DeviceIdentifier(deviceIdentifier, deviceType), -1234);
PreparedStatement stmt = null; PreparedStatement stmt = null;
try { try {
String sql = "DELETE FROM DM_ENROLMENT WHERE DEVICE_ID = ?"; String sql = "UPDATE DM_DEVICE SET TENANT_ID = ? WHERE ID = ? AND TENANT_ID = -1234";
stmt = conn.prepareStatement(sql); stmt = conn.prepareStatement(sql);
stmt.setInt(1, deviceId); stmt.setInt(1, destinationTenantId);
stmt.setInt(2, deviceId);
stmt.executeUpdate(); stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing device enrollment", e); conn.rollback();
throw new DeviceManagementDAOException("Error occurred while removing device", e);
} finally { } finally {
DeviceManagementDAOUtil.cleanupResources(stmt, null); DeviceManagementDAOUtil.cleanupResources(stmt, null);
} }
}
private void removeDeviceGroupMapping(Connection conn, int deviceId) throws DeviceManagementDAOException {
PreparedStatement stmt = null;
try { try {
String sql = "DELETE FROM DM_DEVICE_GROUP_MAP WHERE DEVICE_ID = ?"; String sql = "UPDATE DM_DEVICE_PROPERTIES SET TENANT_ID = ? " +
"WHERE DEVICE_TYPE_NAME = ? AND DEVICE_IDENTIFICATION = ? AND TENANT_ID = -1234";
stmt = conn.prepareStatement(sql); stmt = conn.prepareStatement(sql);
stmt.setInt(1, deviceId); stmt.setInt(1, destinationTenantId);
stmt.setString(2, deviceType);
stmt.setString(3, deviceIdentifier);
stmt.executeUpdate(); stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing device group mapping", e); throw new DeviceManagementDAOException("Error occurred while removing device", e);
} finally { } finally {
DeviceManagementDAOUtil.cleanupResources(stmt, null); DeviceManagementDAOUtil.cleanupResources(stmt, null);
} }
}
private void removeDevice(Connection conn, int deviceId) throws DeviceManagementDAOException {
PreparedStatement stmt = null;
try { try {
String sql = "DELETE FROM DM_DEVICE WHERE ID = ?"; String sql = "UPDATE DM_ENROLMENT SET TENANT_ID = ?, OWNER = ? WHERE DEVICE_ID = ? AND TENANT_ID = -1234";
stmt = conn.prepareStatement(sql); stmt = conn.prepareStatement(sql);
stmt.setInt(1, deviceId); stmt.setInt(1, destinationTenantId);
stmt.setString(2, owner);
stmt.setInt(3, deviceId);
stmt.executeUpdate(); stmt.executeUpdate();
} catch (SQLException e) { } catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while removing device", e); throw new DeviceManagementDAOException("Error occurred while removing device", e);
} finally { } finally {
DeviceManagementDAOUtil.cleanupResources(stmt, null); DeviceManagementDAOUtil.cleanupResources(stmt, null);
} }
return true;
} }
} }

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

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

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

@ -37,6 +37,7 @@ package org.wso2.carbon.device.mgt.core.service;
import org.wso2.carbon.device.mgt.common.Device; import org.wso2.carbon.device.mgt.common.Device;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier; import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceTransferRequest;
import org.wso2.carbon.device.mgt.common.exceptions.DeviceManagementException; import org.wso2.carbon.device.mgt.common.exceptions.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.exceptions.DeviceNotFoundException; import org.wso2.carbon.device.mgt.common.exceptions.DeviceNotFoundException;
import org.wso2.carbon.device.mgt.common.exceptions.DeviceTypeNotFoundException; import org.wso2.carbon.device.mgt.common.exceptions.DeviceTypeNotFoundException;
@ -597,7 +598,7 @@ public interface DeviceManagementProviderService {
boolean disenrollDevice(DeviceIdentifier deviceId) throws DeviceManagementException; 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; boolean isEnrolled(DeviceIdentifier deviceId) throws DeviceManagementException;
@ -760,4 +761,12 @@ public interface DeviceManagementProviderService {
DeviceConfiguration getDeviceConfiguration(Map<String, String> propertyMap) DeviceConfiguration getDeviceConfiguration(Map<String, String> propertyMap)
throws DeviceManagementException, DeviceNotFoundException, UnauthorizedDeviceAccessException, throws DeviceManagementException, DeviceNotFoundException, UnauthorizedDeviceAccessException,
AmbiguousConfigurationException; AmbiguousConfigurationException;
/**
* Transfer device from super tenant to another tenant
*
* @param deviceTransferRequest DTO of the transfer request
* @return tru if device transferee, otherwise false
*/
List<String> transferDeviceToTenant(DeviceTransferRequest deviceTransferRequest) throws DeviceManagementException, DeviceNotFoundException;
} }

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

@ -51,6 +51,7 @@ import org.wso2.carbon.device.mgt.analytics.data.publisher.exception.DataPublish
import org.wso2.carbon.device.mgt.common.Device; import org.wso2.carbon.device.mgt.common.Device;
import org.wso2.carbon.device.mgt.common.DeviceEnrollmentInfoNotification; import org.wso2.carbon.device.mgt.common.DeviceEnrollmentInfoNotification;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier; import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceTransferRequest;
import org.wso2.carbon.device.mgt.common.exceptions.DeviceManagementException; import org.wso2.carbon.device.mgt.common.exceptions.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.DeviceManager; import org.wso2.carbon.device.mgt.common.DeviceManager;
import org.wso2.carbon.device.mgt.common.exceptions.DeviceNotFoundException; import org.wso2.carbon.device.mgt.common.exceptions.DeviceNotFoundException;
@ -100,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.common.type.mgt.DeviceTypePlatformVersion;
import org.wso2.carbon.device.mgt.core.DeviceManagementConstants; import org.wso2.carbon.device.mgt.core.DeviceManagementConstants;
import org.wso2.carbon.device.mgt.core.DeviceManagementPluginRepository; 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.cache.impl.DeviceCacheManagerImpl;
import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager; import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
import org.wso2.carbon.device.mgt.core.config.DeviceManagementConfig; import org.wso2.carbon.device.mgt.core.config.DeviceManagementConfig;
@ -129,6 +131,8 @@ import org.wso2.carbon.email.sender.core.EmailSendingFailedException;
import org.wso2.carbon.email.sender.core.EmailTransportNotConfiguredException; import org.wso2.carbon.email.sender.core.EmailTransportNotConfiguredException;
import org.wso2.carbon.email.sender.core.TypedValue; import org.wso2.carbon.email.sender.core.TypedValue;
import org.wso2.carbon.email.sender.core.service.EmailSenderService; import org.wso2.carbon.email.sender.core.service.EmailSenderService;
import org.wso2.carbon.stratos.common.beans.TenantInfoBean;
import org.wso2.carbon.tenant.mgt.services.TenantMgtAdminService;
import org.wso2.carbon.user.api.UserStoreException; import org.wso2.carbon.user.api.UserStoreException;
import javax.xml.bind.JAXBContext; import javax.xml.bind.JAXBContext;
@ -144,6 +148,7 @@ import java.util.Enumeration;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Arrays;
import java.util.Map; import java.util.Map;
import java.util.Properties; import java.util.Properties;
import java.util.Set; import java.util.Set;
@ -521,72 +526,90 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
} }
@Override @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(); int tenantId = this.getTenantId();
List<Device> existingDevices;
Device device = this.getDevice(deviceId, false); try {
if (device == null) { DeviceManagementDAOFactory.beginTransaction();
if (log.isDebugEnabled()) { existingDevices = deviceDAO.getDevicesByIdentifiers(deviceIdentifiers, tenantId);
log.debug("Device not found for id '" + deviceId.getId() + "'"); 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);
} }
return false; for (Device device : existingDevices) {
} if (!device.getEnrolmentInfo().getStatus().equals(EnrolmentInfo.Status.REMOVED)) {
String msg = "Device " + device.getDeviceIdentifier() + " of type " + device.getType()
if (!device.getEnrolmentInfo().getStatus().equals(EnrolmentInfo.Status.REMOVED)) { + " is not dis-enrolled to permanently delete the device";
String msg = "Device " + deviceId.getId() + " of type " + deviceId.getType() + " is not dis-enrolled to " + log.error(msg);
"permanently delete the device"; DeviceManagementDAOFactory.rollbackTransaction();
log.error(msg); throw new InvalidDeviceException(msg);
throw new DeviceManagementException(msg); }
} else { DeviceCacheKey deviceCacheKey = new DeviceCacheKey();
try { deviceCacheKey.setDeviceId(device.getDeviceIdentifier());
DeviceManagementDAOFactory.beginTransaction(); deviceCacheKey.setDeviceType(device.getType());
deviceDAO.deleteDevice(deviceId, tenantId); 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 { try {
deviceManager.deleteDevice(deviceId, device); // deleting device from the plugin level
entry.getValue().deleteDevices(deviceIdentifierMap.get(entry.getKey()));
} catch (DeviceManagementException e) { } 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); 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); 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);
} 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();
log.error(msg, e);
throw new DeviceManagementException(msg, e);
} finally {
DeviceManagementDAOFactory.closeConnection();
} }
DeviceManagementDAOFactory.commitTransaction();
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 (DeviceManagementDAOException e) {
DeviceManagementDAOFactory.rollbackTransaction();
String msg = "Error occurred while permanently deleting '" + deviceIdentifiers +
"' devices";
log.error(msg, e);
throw new DeviceManagementException(msg, e);
} }
return true;
} }
@Override @Override
@ -1407,29 +1430,26 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
publicSharedDeviceTypesInDB = deviceTypeDAO.getSharedDeviceTypes(); publicSharedDeviceTypesInDB = deviceTypeDAO.getSharedDeviceTypes();
Map<DeviceTypeServiceIdentifier, DeviceManagementService> registeredTypes = Map<DeviceTypeServiceIdentifier, DeviceManagementService> registeredTypes =
pluginRepository.getAllDeviceManagementServices(tenantId); pluginRepository.getAllDeviceManagementServices(tenantId);
Set<String> deviceTypeSetForTenant = new HashSet<>(); // Get the device from the public space, however if there is another device with same name then give
// priority to that
if (registeredTypes != null) { if (deviceTypesProvidedByTenant != null) {
if (deviceTypesProvidedByTenant != null) { for (DeviceType deviceType : deviceTypesProvidedByTenant) {
for (DeviceType deviceType : deviceTypesProvidedByTenant) { deviceTypesResponse.add(deviceType.getName());
DeviceTypeServiceIdentifier providerKey = new DeviceTypeServiceIdentifier(deviceType.getName(), tenantId); }
if (registeredTypes.get(providerKey) != null || deviceType.getDeviceTypeMetaDefinition() != null) { }
deviceTypesResponse.add(deviceType.getName()); if (publicSharedDeviceTypesInDB != null) {
deviceTypeSetForTenant.add(deviceType.getName()); for (String deviceType: publicSharedDeviceTypesInDB) {
} if (!deviceTypesResponse.contains(deviceType)) {
deviceTypesResponse.add(deviceType);
} }
} }
// Get the device from the public space, however if there is another device with same name then give }
// priority to that if (registeredTypes != null) {
if (publicSharedDeviceTypesInDB != null) { for (DeviceTypeServiceIdentifier deviceType: registeredTypes.keySet()) {
for (String deviceType : publicSharedDeviceTypesInDB) { if (!deviceTypesResponse.contains(deviceType.getDeviceType())) {
DeviceTypeServiceIdentifier providerKey = new DeviceTypeServiceIdentifier(deviceType); deviceTypesResponse.add(deviceType.getDeviceType());
if (registeredTypes.get(providerKey) != null && !deviceTypeSetForTenant.contains(deviceType)) {
deviceTypesResponse.add(deviceType);
}
} }
} }
} }
} catch (DeviceManagementDAOException e) { } catch (DeviceManagementDAOException e) {
String msg = "Error occurred while obtaining the device types."; String msg = "Error occurred while obtaining the device types.";
@ -2979,6 +2999,14 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
DeviceCacheManagerImpl.getInstance().removeDeviceFromCache(deviceIdentifier, this.getTenantId()); 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 @Override
public List<GeoCluster> findGeoClusters(String deviceType, GeoCoordinate southWest, GeoCoordinate northEast, public List<GeoCluster> findGeoClusters(String deviceType, GeoCoordinate southWest, GeoCoordinate northEast,
int geohashLength) throws DeviceManagementException { int geohashLength) throws DeviceManagementException {
@ -3486,12 +3514,12 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
} }
try { try {
Device device = this.getDevice(new DeviceIdentifier(deviceProperties.getDeviceIdentifier(),
deviceProperties.getDeviceTypeName()), false);
String owner = device.getEnrolmentInfo().getOwner();
PrivilegedCarbonContext.startTenantFlow(); PrivilegedCarbonContext.startTenantFlow();
PrivilegedCarbonContext ctx = PrivilegedCarbonContext.getThreadLocalCarbonContext(); PrivilegedCarbonContext ctx = PrivilegedCarbonContext.getThreadLocalCarbonContext();
ctx.setTenantId(Integer.parseInt(deviceProperties.getTenantId()), true); ctx.setTenantId(Integer.parseInt(deviceProperties.getTenantId()), true);
Device device = this.getDevice(new DeviceIdentifier(deviceProperties.getDeviceIdentifier(),
deviceProperties.getDeviceTypeName()), false);
String owner = device.getEnrolmentInfo().getOwner();
PlatformConfiguration configuration = this.getConfiguration(device.getType()); PlatformConfiguration configuration = this.getConfiguration(device.getType());
List<ConfigurationEntry> configurationEntries = new ArrayList<>(); List<ConfigurationEntry> configurationEntries = new ArrayList<>();
if (configuration != null) { if (configuration != null) {
@ -3503,6 +3531,65 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
} }
} }
@Override
public List<String> transferDeviceToTenant(DeviceTransferRequest deviceTransferRequest)
throws DeviceManagementException, DeviceNotFoundException {
if (log.isDebugEnabled()) {
log.debug("Attempting to transfer devices to '" +
deviceTransferRequest.getDestinationTenant() + "'");
}
List<String> enrolledDevices = new ArrayList<>();
DeviceIdentifier deviceIdentifier;
for (String deviceId : deviceTransferRequest.getDeviceIds()) {
deviceIdentifier = new DeviceIdentifier();
deviceIdentifier.setId(deviceId);
deviceIdentifier.setType(deviceTransferRequest.getDeviceType());
if (isEnrolled(deviceIdentifier)) {
enrolledDevices.add(deviceId);
} else {
log.warn("Device '" + deviceId + "' is not enrolled with super tenant. Hence excluding from transferring");
}
}
if (enrolledDevices.isEmpty()) {
throw new DeviceNotFoundException("No any enrolled device found to transfer");
}
int destinationTenantId;
String owner;
try {
TenantMgtAdminService tenantMgtAdminService = new TenantMgtAdminService();
TenantInfoBean tenantInfoBean = tenantMgtAdminService.getTenant(deviceTransferRequest.getDestinationTenant());
destinationTenantId = tenantInfoBean.getTenantId();
owner = tenantInfoBean.getAdmin();
} catch (Exception e) {
String msg = "Error getting destination tenant id and admin from domain'" +
deviceTransferRequest.getDestinationTenant() + "'";
log.error(msg);
throw new DeviceManagementException(msg, e);
}
try {
DeviceManagementDAOFactory.openConnection();
List<String> movedDevices = new ArrayList<>();
for (String deviceId : enrolledDevices) {
if (deviceDAO.transferDevice(deviceTransferRequest.getDeviceType(), deviceId, owner, destinationTenantId)){
movedDevices.add(deviceId);
} else {
log.warn("Device '" + deviceId + "' not transferred to tenant " + destinationTenantId);
}
}
DeviceManagementDAOFactory.commitTransaction();
return movedDevices;
} catch (SQLException | DeviceManagementDAOException e) {
DeviceManagementDAOFactory.rollbackTransaction();
String msg = "Error in transferring devices to tenant '" + deviceTransferRequest.getDestinationTenant() + "'";
log.error(msg);
throw new DeviceManagementException(msg, e);
} finally {
DeviceManagementDAOFactory.closeConnection();
}
}
/** /**
* Wrap the device configuration data into DeviceConfiguration bean * Wrap the device configuration data into DeviceConfiguration bean
* @param device Device queried using the properties * @param device Device queried using the properties

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

@ -164,7 +164,7 @@ public interface GroupManagementProviderService {
* @return list of devices in group. * @return list of devices in group.
* @throws GroupManagementException * @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; List<Device> getAllDevicesOfGroup(String groupName) throws GroupManagementException;

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

@ -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.GroupManagementException;
import org.wso2.carbon.device.mgt.common.group.mgt.GroupNotExistException; 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.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.GroupDAO;
import org.wso2.carbon.device.mgt.core.dao.GroupManagementDAOException; import org.wso2.carbon.device.mgt.core.dao.GroupManagementDAOException;
import org.wso2.carbon.device.mgt.core.dao.GroupManagementDAOFactory; 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 static Log log = LogFactory.getLog(GroupManagementProviderServiceImpl.class);
private GroupDAO groupDAO; private GroupDAO groupDAO;
private DeviceDAO deviceDAO;
/** /**
* Set groupDAO from GroupManagementDAOFactory when class instantiate. * Set groupDAO from GroupManagementDAOFactory when class instantiate.
*/ */
public GroupManagementProviderServiceImpl() { public GroupManagementProviderServiceImpl() {
this.groupDAO = GroupManagementDAOFactory.getGroupDAO(); this.groupDAO = GroupManagementDAOFactory.getGroupDAO();
this.deviceDAO = DeviceManagementDAOFactory.getDeviceDAO();
} }
/** /**
@ -627,7 +631,7 @@ public class GroupManagementProviderServiceImpl implements GroupManagementProvid
* {@inheritDoc} * {@inheritDoc}
*/ */
@Override @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 { throws GroupManagementException {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Group devices of group: " + groupId + " start index " + startIndex + " row count " + rowCount); 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); rowCount = DeviceManagerUtil.validateDeviceListPageSize(rowCount);
GroupManagementDAOFactory.openConnection(); GroupManagementDAOFactory.openConnection();
devices = this.groupDAO.getDevices(groupId, startIndex, rowCount, tenantId); 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) { } catch (GroupManagementDAOException | SQLException | DeviceManagementException e) {
String msg = "Error occurred while getting devices in group."; String msg = "Error occurred while getting devices in group.";
log.error(msg, e); log.error(msg, e);
@ -648,6 +662,9 @@ public class GroupManagementProviderServiceImpl implements GroupManagementProvid
throw new GroupManagementException(msg, e); throw new GroupManagementException(msg, e);
} finally { } finally {
GroupManagementDAOFactory.closeConnection(); GroupManagementDAOFactory.closeConnection();
if(requireDeviceProps){
DeviceManagementDAOFactory.closeConnection();
}
} }
return devices; return devices;
} }

3
components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/TestDeviceManager.java
Unescape View File

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

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

@ -138,7 +138,7 @@ public class GroupManagementProviderServiceNegativeTest extends BaseDeviceManage
@Test(description = "This method tests the getDevices method under negative circumstances", expectedExceptions = @Test(description = "This method tests the getDevices method under negative circumstances", expectedExceptions =
{GroupManagementException.class}) {GroupManagementException.class})
public void testGetDevicesWithPagination() throws GroupManagementException { 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", @Test(description = "This method tests the getGroupCount with username when the user name is given as null",

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

@ -225,7 +225,7 @@ public class GroupManagementProviderServiceTest extends BaseDeviceManagementTest
@Test(dependsOnMethods = ("createGroup")) @Test(dependsOnMethods = ("createGroup"))
public void getDevices() throws GroupManagementException { 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); Assert.assertNotNull(devices);
} }

33
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 @Override
public boolean deleteDevice(DeviceIdentifier deviceIdentifier, Device device) throws DeviceManagementException { public void deleteDevices(List<String> deviceIdentifierList) throws DeviceManagementException {
if (propertiesExist) { if (propertiesExist) {
boolean status;
Device existingDevice = this.getDevice(deviceIdentifier);
if (existingDevice == null) {
return false;
}
try { try {
if (log.isDebugEnabled()) { 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(); deviceTypePluginDAOManager.getDeviceTypeDAOHandler().beginTransaction();
status = deviceTypePluginDAOManager.getDeviceDAO().deleteDevice(existingDevice); if (deviceTypePluginDAOManager.getDeviceDAO().deleteDevices(deviceIdentifierList)) {
deviceTypePluginDAOManager.getDeviceTypeDAOHandler().commitTransaction(); 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) { } catch (DeviceTypeMgtPluginException e) {
deviceTypePluginDAOManager.getDeviceTypeDAOHandler().rollbackTransaction(); 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 { } finally {
deviceTypePluginDAOManager.getDeviceTypeDAOHandler().closeConnection(); deviceTypePluginDAOManager.getDeviceTypeDAOHandler().closeConnection();
} }
return status;
} }
return true;
} }
} }

45
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.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.Device; 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.exception.DeviceTypeMgtPluginException;
import org.wso2.carbon.device.mgt.extensions.device.type.template.util.DeviceTypeUtils; 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.PreparedStatement;
import java.sql.ResultSet; import java.sql.ResultSet;
import java.sql.SQLException; import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
@ -215,30 +217,39 @@ public class DeviceTypePluginDAOImpl implements PluginDAO {
} }
@Override @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 { 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) { } 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(); + deviceDAODefinition.getDeviceTableName();
log.error(msg, e); log.error(msg, e);
throw new DeviceTypeMgtPluginException(msg, e); throw new DeviceTypeMgtPluginException(msg, e);
} finally {
DeviceTypeUtils.cleanupResources(stmt, null);
} }
return status;
} }
private String getDeviceTableColumnNames() { 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; List<Device> getAllDevices() throws DeviceTypeMgtPluginException;
boolean deleteDevice(Device device) throws DeviceTypeMgtPluginException; boolean deleteDevices(List<String> deviceIdentifiers) throws DeviceTypeMgtPluginException;
} }

41
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.Connection;
import java.sql.PreparedStatement; import java.sql.PreparedStatement;
import java.sql.ResultSet; import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.SQLException; import java.sql.SQLException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
@ -218,22 +219,38 @@ public class PropertyBasedPluginDAOImpl implements PluginDAO {
} }
@Override @Override
public boolean deleteDevice(Device device) throws DeviceTypeMgtPluginException { public boolean deleteDevices(List<String> deviceIdentifiers) throws DeviceTypeMgtPluginException {
Connection conn;
PreparedStatement stmt = null;
try { 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) { } 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; + deviceType;
log.error(msg, e); log.error(msg, e);
throw new DeviceTypeMgtPluginException(msg, e); throw new DeviceTypeMgtPluginException(msg, e);
} finally {
DeviceTypeUtils.cleanupResources(stmt, null);
} }
} }

7
components/device-mgt/org.wso2.carbon.device.mgt.ui/src/main/resources/jaggeryapps/devicemgt/app/units/cdmf.unit.dynamic.platform.configuration/configuration.hbs
Unescape View File

@ -32,10 +32,3 @@
</div> </div>
</div> </div>
</div> </div>
{{#zone "bottomJs"}}
<script type="text/javascript">
$(document).ready(function () {
loadDynamicDeviceTypeConfig('{{@unit.params.deviceType}}');
});
</script>
{{/zone}}

9
components/device-mgt/org.wso2.carbon.device.mgt.ui/src/main/resources/jaggeryapps/devicemgt/app/units/cdmf.unit.platform.configuration/configuration.hbs
Unescape View File

@ -193,4 +193,13 @@
{{/zone}} {{/zone}}
{{#zone "bottomJs"}} {{#zone "bottomJs"}}
{{js "js/platform-configuration.js"}} {{js "js/platform-configuration.js"}}
<script type="text/javascript">
$(document).ready(function () {
{{#each deviceTypes}}
{{#unless unitName}}
loadDynamicDeviceTypeConfig('{{name}}');
{{/unless}}
{{/each}}
});
</script>
{{/zone}} {{/zone}}

28
components/device-mgt/org.wso2.carbon.device.mgt.ui/src/main/resources/jaggeryapps/devicemgt/app/units/cdmf.unit.platform.configuration/public/js/platform-configuration.js
Unescape View File

@ -163,7 +163,7 @@ var loadDynamicDeviceTypeConfig = function (deviceType) {
configAPI, configAPI,
function (data) { function (data) {
data = JSON.parse(data); data = JSON.parse(data);
var fieldWrapper = "#" + deviceType + "-config-field-wrapper"; var fieldWrapper = "#" + escapeSelector(deviceType + "-config-field-wrapper");
$(fieldWrapper).html(""); $(fieldWrapper).html("");
if (data.configuration) { if (data.configuration) {
var config; var config;
@ -197,15 +197,18 @@ var loadDynamicDeviceTypeConfig = function (deviceType) {
var onDynamicConfigSubmit = function (deviceType) { var onDynamicConfigSubmit = function (deviceType) {
var errorMsgWrapper = "#" + deviceType + "-config-error-msg"; var errorMsgWrapper = "#" + escapeSelector(deviceType + "-config-error-msg");
var errorMsg = "#" + deviceType + "-config-error-msg span"; var errorMsg = "#" + escapeSelector(deviceType + "-config-error-msg span");
var filedRaw = '.' + escapeSelector(deviceType + '-config-row');
var filedName = "." + escapeSelector(deviceType + "-config-name");
var filedValue = "." + escapeSelector(deviceType + "-config-value");
var addConfigFormData = {}; var addConfigFormData = {};
var configList = []; var configList = [];
$('.' + deviceType + '-config-row').each(function () { $(filedRaw).each(function () {
var configName = $(this).find("." + deviceType + "-config-name").val(); var configName = $(this).find(filedName).val();
var configVal = $(this).find("." + deviceType + "-config-value").val(); var configVal = $(this).find(filedValue).val();
if (configName && configName.trim() !== "" && configVal && configVal.trim() !== "") { if (configName && configName.trim() !== "" && configVal && configVal.trim() !== "") {
var configurationEntry = {}; var configurationEntry = {};
configurationEntry.name = configName.trim(); configurationEntry.name = configName.trim();
@ -252,7 +255,8 @@ var onDynamicConfigSubmit = function (deviceType) {
}; };
var onDynamicConfigAddNew = function (deviceType, name, value) { var onDynamicConfigAddNew = function (deviceType, name, value) {
$("#" + deviceType + "-config-field-wrapper").append( var fieldWrapper = "#" + escapeSelector(deviceType + "-config-field-wrapper");
$(fieldWrapper).append(
'<div class="row form-group ' + deviceType + '-config-row"' + '<div class="row form-group ' + deviceType + '-config-row"' +
' id="' + deviceType + '-config-row-' + (++configRowId) + '">' + ' id="' + deviceType + '-config-row-' + (++configRowId) + '">' +
'<div class="col-xs-3">' + '<div class="col-xs-3">' +
@ -272,5 +276,13 @@ var onDynamicConfigAddNew = function (deviceType, name, value) {
}; };
var onDynamicConfigRemove = function (deviceType, rawId) { var onDynamicConfigRemove = function (deviceType, rawId) {
$("#" + deviceType + "-config-row-" + rawId).remove() var fieldWrapper = "#" + escapeSelector(deviceType + "-config-row-" + rawId);
$(fieldWrapper).remove()
};
var escapeSelector = function (text) {
return text.replace(
/([$%&()*+,./:;<=>?@\[\\\]^\{|}~])/g,
'\\$1'
);
}; };

3
components/policy-mgt/org.wso2.carbon.policy.mgt.core/src/test/java/org/wso2/carbon/policy/mgt/core/mock/TypeXDeviceManager.java
Unescape View File

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

6
pom.xml
Unescape View File

@ -1761,6 +1761,12 @@
<version>${tomcat.websocket.version}</version> <version>${tomcat.websocket.version}</version>
<scope>provided</scope> <scope>provided</scope>
</dependency> </dependency>
<dependency>
<groupId>org.wso2.carbon.multitenancy</groupId>
<artifactId>org.wso2.carbon.tenant.mgt</artifactId>
<version>${carbon.multitenancy.version}</version>
<scope>provided</scope>
</dependency>
</dependencies> </dependencies>
</dependencyManagement> </dependencyManagement>

Write Preview
Loading…
Cancel
Save