Merge pull request #1000 from Megala21/master

Improving the existing test cases and adding some negative test cases
4.x.x
sinthuja 7 years ago committed by GitHub
commit abb93758c6

@ -189,6 +189,9 @@ public class DeviceTypeManager implements DeviceManager {
@Override
public boolean saveConfiguration(PlatformConfiguration tenantConfiguration)
throws DeviceManagementException {
if (tenantConfiguration == null) {
throw new DeviceManagementException("Platform configuration is null. Cannot save the configuration");
}
try {
if (log.isDebugEnabled()) {
log.debug("Persisting " + deviceType + " configurations in Registry");
@ -246,6 +249,9 @@ public class DeviceTypeManager implements DeviceManager {
@Override
public boolean enrollDevice(Device device) throws DeviceManagementException {
if (device == null) {
throw new DeviceManagementException("Device is null. Cannot enroll the device.");
}
if (propertiesExist) {
boolean status = false;
boolean isEnrolled = this.isEnrolled(
@ -313,6 +319,9 @@ public class DeviceTypeManager implements DeviceManager {
@Override
public boolean isEnrolled(DeviceIdentifier deviceId) throws DeviceManagementException {
if (deviceId == null) {
throw new DeviceManagementException("Cannot check the enrollment status of a null device");
}
if (propertiesExist) {
boolean isEnrolled = false;
try {
@ -347,6 +356,9 @@ public class DeviceTypeManager implements DeviceManager {
@Override
public Device getDevice(DeviceIdentifier deviceId) throws DeviceManagementException {
if (deviceId == null) {
throw new DeviceManagementException("Cannot get the device. DeviceIdentifier is null");
}
if (propertiesExist) {
Device device;
try {

@ -44,7 +44,6 @@ public class DeviceTypePluginDAOImpl implements PluginDAO {
private String selectDBQueryForGetDevice;
private String createDBqueryForAddDevice;
private String updateDBQueryForUpdateDevice;
private String deleteDBQueryToRemoveDevicd;
private String selectDBQueryToGetAllDevice;
public DeviceTypePluginDAOImpl(DeviceDAODefinition deviceDAODefinition,
@ -158,33 +157,6 @@ public class DeviceTypePluginDAOImpl implements PluginDAO {
return status;
}
public boolean deleteDevice(String deviceId) throws DeviceTypeMgtPluginException {
boolean status = false;
Connection conn = null;
PreparedStatement stmt = null;
try {
conn = deviceTypeDAOHandler.getConnection();
stmt = conn.prepareStatement(deleteDBQueryToRemoveDevicd);
stmt.setString(1, deviceId);
int rows = stmt.executeUpdate();
if (rows > 0) {
status = true;
if (log.isDebugEnabled()) {
log.debug("device " + deviceId + " data has deleted from the " +
deviceDAODefinition.getDeviceTableName() + " table.");
}
}
} catch (SQLException e) {
String msg =
"Error occurred while deleting " + deviceDAODefinition.getDeviceTableName() + " device " + deviceId;
log.error(msg, e);
throw new DeviceTypeMgtPluginException(msg, e);
} finally {
DeviceTypeUtils.cleanupResources(stmt, null);
}
return status;
}
public List<Device> getAllDevices() throws DeviceTypeMgtPluginException {
Connection conn;
PreparedStatement stmt = null;
@ -264,10 +236,6 @@ public class DeviceTypePluginDAOImpl implements PluginDAO {
updateDBQueryForUpdateDevice = "UPDATE " + deviceDAODefinition.getDeviceTableName() + " SET "
+ getDeviceTableColumnNamesForUpdateQuery() + " WHERE " + deviceDAODefinition.getPrimaryKey() + " = ?";
deleteDBQueryToRemoveDevicd =
"DELETE FROM " + deviceDAODefinition.getDeviceTableName() + " WHERE " + deviceDAODefinition
.getPrimaryKey() + " = ?";
selectDBQueryToGetAllDevice =
"SELECT " + getDeviceTableColumnNames() + "," + deviceDAODefinition.getPrimaryKey() + " FROM "
+ deviceDAODefinition.getDeviceTableName();

@ -30,7 +30,5 @@ public interface PluginDAO {
boolean updateDevice(Device device) throws DeviceTypeMgtPluginException;
boolean deleteDevice(String deviceId) throws DeviceTypeMgtPluginException;
List<Device> getAllDevices() throws DeviceTypeMgtPluginException;
}

@ -158,36 +158,6 @@ public class PropertyBasedPluginDAOImpl implements PluginDAO {
}
}
public boolean deleteDevice(String deviceId) throws DeviceTypeMgtPluginException {
boolean status = false;
Connection conn = null;
PreparedStatement stmt = null;
try {
conn = deviceTypeDAOHandler.getConnection();
stmt = conn.prepareStatement("DELETE FROM DM_DEVICE_PROPERTIES WHERE DEVICE_TYPE_NAME = ? " +
"AND DEVICE_IDENTIFICATION = ? AND TENANT_ID = ?");
stmt.setString(1, deviceType);
stmt.setString(2, deviceId);
stmt.setInt(3, PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true));
int rows = stmt.executeUpdate();
if (rows > 0) {
status = true;
if (log.isDebugEnabled()) {
log.debug("device " + deviceId + " data has deleted from the " +
deviceType + " table.");
}
}
} catch (SQLException e) {
String msg =
"Error occurred while deleting " + deviceType + " device " + deviceId;
log.error(msg, e);
throw new DeviceTypeMgtPluginException(msg, e);
} finally {
DeviceTypeUtils.cleanupResources(stmt, null);
}
return status;
}
public List<Device> getAllDevices() throws DeviceTypeMgtPluginException {
Connection conn;
PreparedStatement stmt = null;
@ -220,7 +190,7 @@ public class PropertyBasedPluginDAOImpl implements PluginDAO {
log.debug(
"All device details have fetched from " + deviceType + " table.");
}
return Arrays.asList((Device[])deviceMap.values().toArray());
return new ArrayList<>(deviceMap.values());
} catch (SQLException e) {
String msg =
"Error occurred while fetching all " + deviceType + " device data'";

@ -305,12 +305,12 @@ public class DeviceTypeManagerServiceTest {
DeviceTypeConfigurationException, JAXBException {
ClassLoader classLoader = getClass().getClassLoader();
URL resourceUrl = classLoader.getResource("arduino.xml");
File raspberrypiConfiguration = null;
File arduinoConfiguration = null;
if (resourceUrl != null) {
raspberrypiConfiguration = new File(resourceUrl.getFile());
arduinoConfiguration = new File(resourceUrl.getFile());
}
arduinoDeviceTypeConfiguration = Utils.getDeviceTypeConfiguration(raspberrypiConfiguration);
arduinoDeviceTypeManagerService = new DeviceTypeManagerService(new
DeviceTypeConfigIdentifier("arduino", "carbon.super"), arduinoDeviceTypeConfiguration);
arduinoDeviceTypeConfiguration = Utils.getDeviceTypeConfiguration(arduinoConfiguration);
arduinoDeviceTypeManagerService = new DeviceTypeManagerService(
new DeviceTypeConfigIdentifier("arduino", "carbon.super"), arduinoDeviceTypeConfiguration);
}
}

@ -26,12 +26,16 @@ import org.wso2.carbon.device.mgt.common.Device;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.configuration.mgt.PlatformConfiguration;
import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DeviceDetails;
import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DeviceTypeConfiguration;
import org.wso2.carbon.device.mgt.extensions.device.type.template.config.Properties;
import org.wso2.carbon.device.mgt.extensions.device.type.template.config.exception.DeviceTypeConfigurationException;
import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.DeviceDAODefinition;
import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.DeviceTypeDAOHandler;
import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.DeviceTypePluginDAOImpl;
import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.DeviceTypePluginDAOManager;
import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.PluginDAO;
import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.PropertyBasedPluginDAOImpl;
import org.wso2.carbon.device.mgt.extensions.utils.Utils;
import org.wso2.carbon.registry.core.exceptions.RegistryException;
import org.xml.sax.SAXException;
@ -47,17 +51,26 @@ import java.net.URL;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* This class tests the {@link DeviceTypeManager}
* This class tests the {@link DeviceTypeManager}.
*/
public class DeviceTypeManagerTest {
private DeviceTypeManager androidDeviceTypeManager;
private DeviceTypeManager customDeviceTypeManager;
private DeviceIdentifier nonExistingDeviceIdentifier;
private Device sampleDevice1;
private Device sampleDevice2;
private Device customDevice;
private String androidDeviceType;
private String customDeviceType = "customDeviceType";
private Field datasourceField;
private Field currentConnection;
private Field deviceTypePluginDAOField;
private Field deviceTypeDAOHandlerField;
private String[] customDeviceTypeProperties = {"custom_property", "custom_property2"};
@BeforeTest(description = "Mocking the classes for testing")
public void setup() throws NoSuchFieldException, IllegalAccessException, IOException, SQLException, SAXException,
@ -67,26 +80,33 @@ public class DeviceTypeManagerTest {
androidDeviceType = "android";
File androidDatabaseScript = null;
javax.sql.DataSource dataSource = null;
File carbonHome = new File("src/test/resources/carbon-home");
File androidConfiguration = null;
if (resourceUrl != null) {
androidDatabaseScript = new File(resourceUrl.getFile());
}
if (carbonHome.exists()) {
System.setProperty("carbon.home", carbonHome.getAbsolutePath());
}
resourceUrl = classLoader.getResource("android.xml");
File androidConfiguration = null;
if (resourceUrl != null) {
androidConfiguration = new File(resourceUrl.getFile());
}
datasourceField = DeviceTypeDAOHandler.class.getDeclaredField("dataSource");
datasourceField.setAccessible(true);
currentConnection = DeviceTypeDAOHandler.class.getDeclaredField("currentConnection");
currentConnection.setAccessible(true);
deviceTypePluginDAOField = DeviceTypePluginDAOManager.class.getDeclaredField("deviceTypePluginDAO");
deviceTypePluginDAOField.setAccessible(true);
deviceTypeDAOHandlerField = DeviceTypePluginDAOManager.class.getDeclaredField("deviceTypeDAOHandler");
deviceTypeDAOHandlerField.setAccessible(true);
DeviceTypeConfiguration androidDeviceConfiguration = Utils.getDeviceTypeConfiguration(androidConfiguration);
androidDeviceTypeManager = Mockito.mock(DeviceTypeManager.class, Mockito.CALLS_REAL_METHODS);
customDeviceTypeManager = Mockito.mock(DeviceTypeManager.class, Mockito.CALLS_REAL_METHODS);
if (androidDatabaseScript != null) {
dataSource = Utils.createDataTables("deviceType", androidDatabaseScript.getAbsolutePath());
dataSource = Utils.createDataTables("customDeviceType", androidDatabaseScript.getAbsolutePath());
}
DeviceTypePluginDAOManager deviceTypePluginDAOManager = createMockDeviceTypePluginDAOManager(dataSource,
DeviceTypePluginDAOManager deviceTypePluginDAOManager = createandroidDeviceTypePluginDAOManager(dataSource,
androidDeviceConfiguration);
Field deviceTypePluginDAOManagerField = DeviceTypeManager.class.getDeclaredField("deviceTypePluginDAOManager");
deviceTypePluginDAOManagerField.setAccessible(true);
@ -96,9 +116,16 @@ public class DeviceTypeManagerTest {
propertiesExist.setAccessible(true);
Field deviceType = DeviceTypeManager.class.getDeclaredField("deviceType");
deviceType.setAccessible(true);
deviceType.set(androidDeviceTypeManager, androidDeviceType);
propertiesExist.set(androidDeviceTypeManager, true);
createDevice();
createAndroidDevice();
DeviceTypePluginDAOManager propertyBasedPluginDAOManager = createPluginBasedDeviceTypeManager();
deviceTypePluginDAOManagerField.set(customDeviceTypeManager, propertyBasedPluginDAOManager);
deviceType.set(customDeviceTypeManager, customDeviceType);
propertiesExist.set(customDeviceTypeManager, true);
createCustomDevice();
}
@Test(description = "This test case tests IsEnrolled method of the DeviceTypeManager",
@ -106,10 +133,17 @@ public class DeviceTypeManagerTest {
public void testIsEnrolled() throws DeviceManagementException {
DeviceIdentifier deviceIdentifier = new DeviceIdentifier(sampleDevice2.getDeviceIdentifier(),
sampleDevice2.getType());
Assert.assertTrue(!androidDeviceTypeManager.isEnrolled(nonExistingDeviceIdentifier),
"Device with " + "NON-Existing ID is not enrolled, but this shows as enrolled");
DeviceIdentifier nonExistingCustomDeviceIdentifier = new DeviceIdentifier(sampleDevice2.getDeviceIdentifier(),
customDevice.getType());
Assert.assertFalse(androidDeviceTypeManager.isEnrolled(nonExistingDeviceIdentifier),
"Device with NON-Existing ID is not enrolled, but this shows as enrolled");
Assert.assertTrue(androidDeviceTypeManager.isEnrolled(deviceIdentifier),
"Enrolled device is shown as un-enrolled");
Assert.assertFalse(customDeviceTypeManager.isEnrolled(nonExistingCustomDeviceIdentifier),
"Custom device type manager returns an non-existing device as enrolled");
Assert.assertTrue(customDeviceTypeManager.isEnrolled(new DeviceIdentifier(customDeviceType, customDeviceType))
, "Enrolled device is shown as un-enrolled in custom device type manager");
}
@Test(description = "This test case tests the getDevcie method of the DeviceTypeManager", dependsOnMethods =
@ -120,20 +154,37 @@ public class DeviceTypeManagerTest {
Assert.assertNull(androidDeviceTypeManager.getDevice(nonExistingDeviceIdentifier),
"Non existing sampleDevice was retrieved");
Assert.assertNotNull(androidDeviceTypeManager.getDevice(existingDeviceIdntifier),
"Existing sampleDevice was retrieved");
"Existing sampleDevice was not retrieved");
Device customDevice1 = customDeviceTypeManager
.getDevice(new DeviceIdentifier(customDeviceType, customDeviceType));
Assert.assertEquals(customDevice1.getProperties().size(), 2,
"GetDevice call" + " failed in custom deviceTypeManager");
}
@Test(description = "This test case tests the enrollment of the device")
public void testEnrollDevice() throws DeviceManagementException {
Assert.assertTrue(androidDeviceTypeManager.enrollDevice(sampleDevice1));
Assert.assertTrue(!androidDeviceTypeManager.enrollDevice(sampleDevice2));
Assert.assertTrue(androidDeviceTypeManager.enrollDevice(sampleDevice1), "New android device enrollment failed");
Assert.assertFalse(androidDeviceTypeManager.enrollDevice(sampleDevice2),
"Modification to existing android " + "device enrollment failed");
Assert.assertTrue(customDeviceTypeManager.enrollDevice(customDevice), "Custom device type enrollment failed.");
List<Device.Property> properties = customDevice.getProperties();
Device.Property property = new Device.Property();
property.setName("test");
property.setValue("test");
properties.add(property);
customDevice.setProperties(properties);
Assert.assertFalse(customDeviceTypeManager.enrollDevice(customDevice),
"Custom device type re-enrollment " + "failed.");
}
@Test(description = "This test case tests the get all devices method of the DeviceTypeManager", dependsOnMethods
= {"testEnrollDevice"})
public void testGetAllDevices() throws DeviceManagementException {
Assert.assertEquals(androidDeviceTypeManager.getAllDevices().size(), 1,
"All the added devices are not fetched " + "from the database");
"All the added devices are not fetched from the database");
Assert.assertEquals(customDeviceTypeManager.getAllDevices().size(), 1,
"All the added devices are not fetched from the database");
}
@Test(description = "This test case tests the addition of platform configuration and retrieval of the same")
@ -147,6 +198,7 @@ public class DeviceTypeManagerTest {
"Platform Configuration saved and retrieved correctly in " + "DeviceType Manager");
Assert.assertEquals(actualPlatformConfiguration.getType(), androidDeviceType,
"Platform Configuration saved and " + "retrieved correctly in DeviceType Manager");
Assert.assertNull(customDeviceTypeManager.getConfiguration());
}
@Test (description = "This test case tests the getDefaultConfiguration method")
@ -169,9 +221,9 @@ public class DeviceTypeManagerTest {
}
/**
* To create a sample sampleDevice to add to DAO Layer.
* To create sample android devices to add to DAO Layer.
*/
private void createDevice() {
private void createAndroidDevice() {
nonExistingDeviceIdentifier = new DeviceIdentifier("NON-EXISTING", androidDeviceType);
List<Device.Property> list = new ArrayList<>();
@ -190,6 +242,21 @@ public class DeviceTypeManagerTest {
sampleDevice2 = new Device("testdevice1", androidDeviceType, "test", "testdevice", null, null, list);
}
/**
* To create a sample custom device.
*/
private void createCustomDevice () {
List<Device.Property> list = new ArrayList<>();
for(String customProperty : customDeviceTypeProperties) {
Device.Property property = new Device.Property();
property.setName(customProperty);
property.setValue(customProperty);
list.add(property);
}
customDevice = new Device(customDeviceType, customDeviceType, customDeviceType, customDeviceType, null,
null, list);
}
/*
* To create a mock sampleDevice type plugin dao manager.
* @param dataSource DataSource for the DAO layer
@ -198,13 +265,8 @@ public class DeviceTypeManagerTest {
* @throws NoSuchFieldException No Such Field Exception
* @throws IllegalAccessException Illegal Access Exception
*/
private DeviceTypePluginDAOManager createMockDeviceTypePluginDAOManager(javax.sql.DataSource dataSource,
private DeviceTypePluginDAOManager createandroidDeviceTypePluginDAOManager(javax.sql.DataSource dataSource,
DeviceTypeConfiguration androidDeviceConfiguration) throws NoSuchFieldException, IllegalAccessException {
Field datasourceField = DeviceTypeDAOHandler.class.getDeclaredField("dataSource");
datasourceField.setAccessible(true);
Field currentConnection = DeviceTypeDAOHandler.class.getDeclaredField("currentConnection");
currentConnection.setAccessible(true);
DeviceTypeDAOHandler deviceTypeDAOHandler = Mockito
.mock(DeviceTypeDAOHandler.class, Mockito.CALLS_REAL_METHODS);
datasourceField.set(deviceTypeDAOHandler, dataSource);
@ -213,13 +275,52 @@ public class DeviceTypeManagerTest {
DeviceDAODefinition deviceDAODefinition = Utils.getDeviceDAODefinition(androidDeviceConfiguration);
DeviceTypePluginDAOImpl deviceTypePluginDAO = new DeviceTypePluginDAOImpl(deviceDAODefinition,
deviceTypeDAOHandler);
DeviceTypePluginDAOManager deviceTypePluginDAOManager = Mockito
.mock(DeviceTypePluginDAOManager.class, Mockito.CALLS_REAL_METHODS);
deviceTypePluginDAOField.set(deviceTypePluginDAOManager, deviceTypePluginDAO);
deviceTypeDAOHandlerField.set(deviceTypePluginDAOManager, deviceTypeDAOHandler);
return deviceTypePluginDAOManager;
}
/**
* To create a plugin based device type manager.
*
* @return Plugin based device type manager.
* @throws IOException IO Exception.
* @throws SQLException SQL Exception
* @throws NoSuchFieldException No Such File Exception.
* @throws IllegalAccessException Illegal Access Exception.
*/
private DeviceTypePluginDAOManager createPluginBasedDeviceTypeManager()
throws IOException, SQLException, NoSuchFieldException, IllegalAccessException {
ClassLoader classLoader = getClass().getClassLoader();
URL resourceUrl = classLoader.getResource("h2.sql");
File cdmDataScript = null;
javax.sql.DataSource dataSource = null;
if (resourceUrl != null) {
cdmDataScript = new File(resourceUrl.getFile());
}
if (cdmDataScript != null) {
dataSource = Utils.createDataTables(customDeviceType, cdmDataScript.getAbsolutePath());
}
DeviceDetails deviceDetails = new DeviceDetails();
List<String> propertyList = new ArrayList<>();
propertyList.addAll(Arrays.asList(customDeviceTypeProperties));
Properties properties = new Properties();
properties.addProperties(propertyList);
deviceDetails.setProperties(properties);
DeviceTypeDAOHandler deviceTypeDAOHandler = Mockito
.mock(DeviceTypeDAOHandler.class, Mockito.CALLS_REAL_METHODS);
datasourceField.set(deviceTypeDAOHandler, dataSource);
currentConnection.set(deviceTypeDAOHandler, new ThreadLocal<Connection>());
PluginDAO deviceTypePluginDAO = new PropertyBasedPluginDAOImpl(deviceDetails, deviceTypeDAOHandler,
customDeviceType);
DeviceTypePluginDAOManager deviceTypePluginDAOManager = Mockito
.mock(DeviceTypePluginDAOManager.class, Mockito.CALLS_REAL_METHODS);
Field deviceTypePluginDAOField = DeviceTypePluginDAOManager.class.getDeclaredField("deviceTypePluginDAO");
deviceTypePluginDAOField.setAccessible(true);
Field deviceTypeDAOHandlerField = DeviceTypePluginDAOManager.class.getDeclaredField("deviceTypeDAOHandler");
deviceTypeDAOHandlerField.setAccessible(true);
deviceTypePluginDAOField.set(deviceTypePluginDAOManager, deviceTypePluginDAO);
deviceTypeDAOHandlerField.set(deviceTypePluginDAOManager, deviceTypeDAOHandler);

@ -21,34 +21,19 @@ package org.wso2.carbon.device.mgt.extensions.device.type.template;
import org.testng.Assert;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import org.wso2.carbon.CarbonConstants;
import org.wso2.carbon.base.MultitenantConstants;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.context.RegistryType;
import org.wso2.carbon.context.internal.OSGiDataHolder;
import org.wso2.carbon.device.mgt.common.Device;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.configuration.mgt.PlatformConfiguration;
import org.wso2.carbon.device.mgt.common.license.mgt.License;
import org.wso2.carbon.device.mgt.common.push.notification.PushNotificationConfig;
import org.wso2.carbon.device.mgt.common.spi.DeviceManagementService;
import org.wso2.carbon.device.mgt.common.type.mgt.DeviceTypeMetaDefinition;
import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DeviceTypeConfiguration;
import org.wso2.carbon.device.mgt.extensions.device.type.template.config.Feature;
import org.wso2.carbon.device.mgt.extensions.device.type.template.config.Operation;
import org.wso2.carbon.device.mgt.extensions.device.type.template.config.PushNotificationProvider;
import org.wso2.carbon.device.mgt.extensions.device.type.template.config.exception.DeviceTypeConfigurationException;
import org.wso2.carbon.device.mgt.extensions.internal.DeviceTypeExtensionDataHolder;
import org.wso2.carbon.device.mgt.extensions.license.mgt.registry.RegistryBasedLicenseManager;
import org.wso2.carbon.device.mgt.extensions.utils.Utils;
import org.wso2.carbon.governance.api.util.GovernanceArtifactConfiguration;
import org.wso2.carbon.governance.api.util.GovernanceUtils;
import org.wso2.carbon.registry.core.Registry;
import org.wso2.carbon.registry.core.exceptions.RegistryException;
import org.wso2.carbon.registry.core.service.RegistryService;
import org.wso2.carbon.registry.core.session.UserRegistry;
import org.wso2.carbon.utils.FileUtil;
import org.xml.sax.SAXException;
import javax.xml.bind.JAXBException;
@ -59,8 +44,6 @@ import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import static org.wso2.carbon.governance.api.util.GovernanceUtils.getGovernanceArtifactConfiguration;
/**
* This test case contains the tests for {@link HTTPDeviceTypeManagerService} and {@link DeviceTypeGeneratorServiceImpl}
*/
@ -69,7 +52,6 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
private HTTPDeviceTypeManagerService httpDeviceTypeManagerService;
private DeviceTypeGeneratorServiceImpl deviceTypeGeneratorService;
private String androidSenseDeviceType = "androidsense";
private String sampleDeviceType = "sample";
@BeforeTest
public void setup() throws RegistryException, IOException, SAXException, ParserConfigurationException,
@ -100,12 +82,38 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
@Test(description = "This test case tests the populate device management service method")
public void testPopulateDeviceManagementService() {
String sampleDeviceType = "sample";
DeviceManagementService deviceManagementService = deviceTypeGeneratorService
.populateDeviceManagementService(sampleDeviceType, deviceTypeMetaDefinition);
Assert.assertEquals(deviceManagementService.getType(), sampleDeviceType,
"DeviceTypeGeneration for the " + "sample device type failed");
}
@Test(description = "This test case tests the negative scenarios when saving the platform configurations",
expectedExceptions = {DeviceManagementException.class})
public void testSaveConfiguration() throws DeviceManagementException {
httpDeviceTypeManagerService.getDeviceManager().saveConfiguration(null);
}
@Test(description = "This test case tests the negative scenarios when getting a device",
expectedExceptions = {DeviceManagementException.class})
public void testGetDevice() throws DeviceManagementException {
httpDeviceTypeManagerService.getDeviceManager().getDevice(null);
}
@Test(description = "This test case tests the negative scenario when checking whether a device has enrolled",
expectedExceptions = {DeviceManagementException.class})
public void testIsEnrolled() throws DeviceManagementException {
httpDeviceTypeManagerService.getDeviceManager().isEnrolled(null);
}
@Test(description = "This test case tests the negative scenario when enrolling a device",
expectedExceptions = {DeviceManagementException.class})
public void testEnroll() throws DeviceManagementException {
httpDeviceTypeManagerService.getDeviceManager().enrollDevice(null);
}
/**
* To create a sample device type meta defintion.
* @throws SAXException SAX Exception.

@ -0,0 +1,531 @@
CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE (
ID INT AUTO_INCREMENT NOT NULL,
NAME VARCHAR(300) NULL DEFAULT NULL,
DEVICE_TYPE_META VARCHAR(20000) NULL DEFAULT NULL,
LAST_UPDATED_TIMESTAMP TIMESTAMP NOT NULL,
PROVIDER_TENANT_ID INTEGER DEFAULT 0,
SHARED_WITH_ALL_TENANTS BOOLEAN NOT NULL DEFAULT FALSE,
PRIMARY KEY (ID)
);
CREATE TABLE IF NOT EXISTS DM_GROUP (
ID INTEGER AUTO_INCREMENT NOT NULL,
GROUP_NAME VARCHAR(100) DEFAULT NULL,
DESCRIPTION TEXT DEFAULT NULL,
OWNER VARCHAR(45) DEFAULT NULL,
TENANT_ID INTEGER DEFAULT 0,
PRIMARY KEY (ID)
);
CREATE TABLE IF NOT EXISTS DM_ROLE_GROUP_MAP (
ID INTEGER AUTO_INCREMENT NOT NULL,
GROUP_ID INTEGER DEFAULT NULL,
ROLE VARCHAR(45) DEFAULT NULL,
TENANT_ID INTEGER DEFAULT 0,
PRIMARY KEY (ID),
CONSTRAINT fk_DM_ROLE_GROUP_MAP_DM_GROUP2 FOREIGN KEY (GROUP_ID)
REFERENCES DM_GROUP (ID) ON DELETE CASCADE ON UPDATE CASCADE
);
CREATE TABLE IF NOT EXISTS DM_DEVICE (
ID INTEGER auto_increment NOT NULL,
DESCRIPTION TEXT DEFAULT NULL,
NAME VARCHAR(100) DEFAULT NULL,
DEVICE_TYPE_ID INT(11) DEFAULT NULL,
DEVICE_IDENTIFICATION VARCHAR(300) DEFAULT NULL,
LAST_UPDATED_TIMESTAMP TIMESTAMP NOT NULL,
TENANT_ID INTEGER DEFAULT 0,
PRIMARY KEY (ID),
CONSTRAINT fk_DM_DEVICE_DM_DEVICE_TYPE2 FOREIGN KEY (DEVICE_TYPE_ID)
REFERENCES DM_DEVICE_TYPE (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
CONSTRAINT uk_DM_DEVICE UNIQUE (NAME, DEVICE_TYPE_ID, DEVICE_IDENTIFICATION, TENANT_ID)
);
CREATE TABLE IF NOT EXISTS DM_DEVICE_PROPERTIES (
DEVICE_TYPE_NAME VARCHAR(300) NOT NULL,
DEVICE_IDENTIFICATION VARCHAR(300) NOT NULL,
PROPERTY_NAME VARCHAR(100) DEFAULT 0,
PROPERTY_VALUE VARCHAR(100) DEFAULT NULL,
TENANT_ID VARCHAR(100),
PRIMARY KEY (DEVICE_TYPE_NAME, DEVICE_IDENTIFICATION, PROPERTY_NAME, TENANT_ID)
);
CREATE TABLE IF NOT EXISTS DM_DEVICE_GROUP_MAP (
ID INTEGER AUTO_INCREMENT NOT NULL,
DEVICE_ID INTEGER DEFAULT NULL,
GROUP_ID INTEGER DEFAULT NULL,
TENANT_ID INTEGER DEFAULT 0,
PRIMARY KEY (ID),
CONSTRAINT fk_DM_DEVICE_GROUP_MAP_DM_DEVICE2 FOREIGN KEY (DEVICE_ID)
REFERENCES DM_DEVICE (ID) ON DELETE CASCADE ON UPDATE CASCADE,
CONSTRAINT fk_DM_DEVICE_GROUP_MAP_DM_GROUP2 FOREIGN KEY (GROUP_ID)
REFERENCES DM_GROUP (ID) ON DELETE CASCADE ON UPDATE CASCADE
);
CREATE TABLE IF NOT EXISTS DM_OPERATION (
ID INTEGER AUTO_INCREMENT NOT NULL,
TYPE VARCHAR(50) NOT NULL,
CREATED_TIMESTAMP TIMESTAMP NOT NULL,
RECEIVED_TIMESTAMP TIMESTAMP NULL,
OPERATION_CODE VARCHAR(1000) NOT NULL,
PRIMARY KEY (ID)
);
CREATE TABLE IF NOT EXISTS DM_CONFIG_OPERATION (
OPERATION_ID INTEGER NOT NULL,
OPERATION_CONFIG BLOB DEFAULT NULL,
ENABLED BOOLEAN NOT NULL DEFAULT FALSE,
PRIMARY KEY (OPERATION_ID),
CONSTRAINT fk_dm_operation_config FOREIGN KEY (OPERATION_ID) REFERENCES
DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_COMMAND_OPERATION (
OPERATION_ID INTEGER NOT NULL,
ENABLED BOOLEAN NOT NULL DEFAULT FALSE,
PRIMARY KEY (OPERATION_ID),
CONSTRAINT fk_dm_operation_command FOREIGN KEY (OPERATION_ID) REFERENCES
DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_POLICY_OPERATION (
OPERATION_ID INTEGER NOT NULL,
ENABLED INTEGER NOT NULL DEFAULT 0,
OPERATION_DETAILS BLOB DEFAULT NULL,
PRIMARY KEY (OPERATION_ID),
CONSTRAINT fk_dm_operation_policy FOREIGN KEY (OPERATION_ID) REFERENCES
DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_PROFILE_OPERATION (
OPERATION_ID INTEGER NOT NULL,
ENABLED INTEGER NOT NULL DEFAULT 0,
OPERATION_DETAILS BLOB DEFAULT NULL,
PRIMARY KEY (OPERATION_ID),
CONSTRAINT fk_dm_operation_profile FOREIGN KEY (OPERATION_ID) REFERENCES
DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_ENROLMENT (
ID INTEGER AUTO_INCREMENT NOT NULL,
DEVICE_ID INTEGER NOT NULL,
OWNER VARCHAR(50) NOT NULL,
OWNERSHIP VARCHAR(45) DEFAULT NULL,
STATUS VARCHAR(50) NULL,
DATE_OF_ENROLMENT TIMESTAMP DEFAULT NULL,
DATE_OF_LAST_UPDATE TIMESTAMP DEFAULT NULL,
TENANT_ID INT NOT NULL,
PRIMARY KEY (ID),
CONSTRAINT fk_dm_device_enrolment FOREIGN KEY (DEVICE_ID) REFERENCES
DM_DEVICE (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
CONSTRAINT uk_dm_device_enrolment UNIQUE (DEVICE_ID, OWNER, OWNERSHIP, TENANT_ID)
);
CREATE TABLE IF NOT EXISTS DM_ENROLMENT_OP_MAPPING (
ID INTEGER AUTO_INCREMENT NOT NULL,
ENROLMENT_ID INTEGER NOT NULL,
OPERATION_ID INTEGER NOT NULL,
STATUS VARCHAR(50) NULL,
PUSH_NOTIFICATION_STATUS VARCHAR(50) NULL,
CREATED_TIMESTAMP INT NOT NULL,
UPDATED_TIMESTAMP INT NOT NULL,
PRIMARY KEY (ID),
CONSTRAINT fk_dm_device_operation_mapping_device FOREIGN KEY (ENROLMENT_ID) REFERENCES
DM_ENROLMENT (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
CONSTRAINT fk_dm_device_operation_mapping_operation FOREIGN KEY (OPERATION_ID) REFERENCES
DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_DEVICE_OPERATION_RESPONSE (
ID INTEGER AUTO_INCREMENT NOT NULL,
ENROLMENT_ID INTEGER NOT NULL,
OPERATION_ID INTEGER NOT NULL,
EN_OP_MAP_ID INTEGER NOT NULL,
OPERATION_RESPONSE LONGBLOB DEFAULT NULL,
RECEIVED_TIMESTAMP TIMESTAMP NULL,
PRIMARY KEY (ID),
CONSTRAINT fk_dm_device_operation_response_enrollment FOREIGN KEY (ENROLMENT_ID) REFERENCES
DM_ENROLMENT (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
CONSTRAINT fk_dm_device_operation_response_operation FOREIGN KEY (OPERATION_ID) REFERENCES
DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
CONSTRAINT fk_dm_en_op_map_response FOREIGN KEY (EN_OP_MAP_ID) REFERENCES
DM_ENROLMENT_OP_MAPPING (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
);
-- POLICY RELATED TABLES --
CREATE TABLE IF NOT EXISTS DM_PROFILE (
ID INT NOT NULL AUTO_INCREMENT ,
PROFILE_NAME VARCHAR(45) NOT NULL ,
TENANT_ID INT NOT NULL ,
DEVICE_TYPE VARCHAR(300) NOT NULL ,
CREATED_TIME DATETIME NOT NULL ,
UPDATED_TIME DATETIME NOT NULL ,
PRIMARY KEY (ID)
);
CREATE TABLE IF NOT EXISTS DM_POLICY (
ID INT(11) NOT NULL AUTO_INCREMENT ,
NAME VARCHAR(45) DEFAULT NULL ,
DESCRIPTION VARCHAR(1000) NULL,
TENANT_ID INT(11) NOT NULL ,
PROFILE_ID INT(11) NOT NULL ,
OWNERSHIP_TYPE VARCHAR(45) NULL,
COMPLIANCE VARCHAR(100) NULL,
PRIORITY INT NOT NULL,
ACTIVE INT(2) NOT NULL,
UPDATED INT(1) NULL,
PRIMARY KEY (ID) ,
CONSTRAINT FK_DM_PROFILE_DM_POLICY
FOREIGN KEY (PROFILE_ID )
REFERENCES DM_PROFILE (ID )
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_DEVICE_POLICY (
ID INT(11) NOT NULL AUTO_INCREMENT ,
DEVICE_ID INT(11) NOT NULL ,
ENROLMENT_ID INT(11) NOT NULL,
DEVICE BLOB NOT NULL,
POLICY_ID INT(11) NOT NULL ,
PRIMARY KEY (ID) ,
CONSTRAINT FK_POLICY_DEVICE_POLICY
FOREIGN KEY (POLICY_ID )
REFERENCES DM_POLICY (ID )
ON DELETE NO ACTION
ON UPDATE NO ACTION,
CONSTRAINT FK_DEVICE_DEVICE_POLICY
FOREIGN KEY (DEVICE_ID )
REFERENCES DM_DEVICE (ID )
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE_POLICY (
ID INT(11) NOT NULL ,
DEVICE_TYPE VARCHAR(300) NOT NULL ,
POLICY_ID INT(11) NOT NULL ,
PRIMARY KEY (ID) ,
CONSTRAINT FK_DEVICE_TYPE_POLICY
FOREIGN KEY (POLICY_ID )
REFERENCES DM_POLICY (ID )
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_PROFILE_FEATURES (
ID INT(11) NOT NULL AUTO_INCREMENT,
PROFILE_ID INT(11) NOT NULL,
FEATURE_CODE VARCHAR(100) NOT NULL,
DEVICE_TYPE VARCHAR(300) NOT NULL,
TENANT_ID INT(11) NOT NULL ,
CONTENT BLOB NULL DEFAULT NULL,
PRIMARY KEY (ID),
CONSTRAINT FK_DM_PROFILE_DM_POLICY_FEATURES
FOREIGN KEY (PROFILE_ID)
REFERENCES DM_PROFILE (ID)
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_ROLE_POLICY (
ID INT(11) NOT NULL AUTO_INCREMENT ,
ROLE_NAME VARCHAR(45) NOT NULL ,
POLICY_ID INT(11) NOT NULL ,
PRIMARY KEY (ID) ,
CONSTRAINT FK_ROLE_POLICY_POLICY
FOREIGN KEY (POLICY_ID )
REFERENCES DM_POLICY (ID )
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_USER_POLICY (
ID INT NOT NULL AUTO_INCREMENT ,
POLICY_ID INT NOT NULL ,
USERNAME VARCHAR(45) NOT NULL ,
PRIMARY KEY (ID) ,
CONSTRAINT DM_POLICY_USER_POLICY
FOREIGN KEY (POLICY_ID )
REFERENCES DM_POLICY (ID )
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_DEVICE_POLICY_APPLIED (
ID INT NOT NULL AUTO_INCREMENT ,
DEVICE_ID INT NOT NULL ,
ENROLMENT_ID INT(11) NOT NULL,
POLICY_ID INT NOT NULL ,
POLICY_CONTENT BLOB NULL ,
TENANT_ID INT NOT NULL,
APPLIED TINYINT(1) NULL ,
CREATED_TIME TIMESTAMP NULL ,
UPDATED_TIME TIMESTAMP NULL ,
APPLIED_TIME TIMESTAMP NULL ,
PRIMARY KEY (ID) ,
CONSTRAINT FK_DM_POLICY_DEVCIE_APPLIED
FOREIGN KEY (DEVICE_ID )
REFERENCES DM_DEVICE (ID )
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_CRITERIA (
ID INT NOT NULL AUTO_INCREMENT,
TENANT_ID INT NOT NULL,
NAME VARCHAR(50) NULL,
PRIMARY KEY (ID)
);
CREATE TABLE IF NOT EXISTS DM_POLICY_CRITERIA (
ID INT NOT NULL AUTO_INCREMENT,
CRITERIA_ID INT NOT NULL,
POLICY_ID INT NOT NULL,
PRIMARY KEY (ID),
CONSTRAINT FK_CRITERIA_POLICY_CRITERIA
FOREIGN KEY (CRITERIA_ID)
REFERENCES DM_CRITERIA (ID)
ON DELETE NO ACTION
ON UPDATE NO ACTION,
CONSTRAINT FK_POLICY_POLICY_CRITERIA
FOREIGN KEY (POLICY_ID)
REFERENCES DM_POLICY (ID)
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_POLICY_CRITERIA_PROPERTIES (
ID INT NOT NULL AUTO_INCREMENT,
POLICY_CRITERION_ID INT NOT NULL,
PROP_KEY VARCHAR(45) NULL,
PROP_VALUE VARCHAR(100) NULL,
CONTENT BLOB NULL COMMENT 'This is used to ',
PRIMARY KEY (ID),
CONSTRAINT FK_POLICY_CRITERIA_PROPERTIES
FOREIGN KEY (POLICY_CRITERION_ID)
REFERENCES DM_POLICY_CRITERIA (ID)
ON DELETE CASCADE
ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_POLICY_COMPLIANCE_STATUS (
ID INT NOT NULL AUTO_INCREMENT,
DEVICE_ID INT NOT NULL,
ENROLMENT_ID INT(11) NOT NULL,
POLICY_ID INT NOT NULL,
TENANT_ID INT NOT NULL,
STATUS INT NULL,
LAST_SUCCESS_TIME TIMESTAMP NULL,
LAST_REQUESTED_TIME TIMESTAMP NULL,
LAST_FAILED_TIME TIMESTAMP NULL,
ATTEMPTS INT NULL,
PRIMARY KEY (ID)
);
CREATE TABLE IF NOT EXISTS DM_POLICY_CHANGE_MGT (
ID INT NOT NULL AUTO_INCREMENT,
POLICY_ID INT NOT NULL,
DEVICE_TYPE VARCHAR(300) NOT NULL ,
TENANT_ID INT(11) NOT NULL,
PRIMARY KEY (ID)
);
CREATE TABLE IF NOT EXISTS DM_POLICY_COMPLIANCE_FEATURES (
ID INT NOT NULL AUTO_INCREMENT,
COMPLIANCE_STATUS_ID INT NOT NULL,
TENANT_ID INT NOT NULL,
FEATURE_CODE VARCHAR(100) NOT NULL,
STATUS INT NULL,
PRIMARY KEY (ID),
CONSTRAINT FK_COMPLIANCE_FEATURES_STATUS
FOREIGN KEY (COMPLIANCE_STATUS_ID)
REFERENCES DM_POLICY_COMPLIANCE_STATUS (ID)
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_APPLICATION (
ID INTEGER AUTO_INCREMENT NOT NULL,
NAME VARCHAR(150) NOT NULL,
APP_IDENTIFIER VARCHAR(150) NOT NULL,
PLATFORM VARCHAR(50) DEFAULT NULL,
CATEGORY VARCHAR(50) NULL,
VERSION VARCHAR(50) NULL,
TYPE VARCHAR(50) NULL,
LOCATION_URL VARCHAR(100) DEFAULT NULL,
IMAGE_URL VARCHAR(100) DEFAULT NULL,
APP_PROPERTIES BLOB NULL,
MEMORY_USAGE INTEGER(10) NULL,
IS_ACTIVE BOOLEAN NOT NULL DEFAULT FALSE,
TENANT_ID INTEGER NOT NULL,
PRIMARY KEY (ID)
);
CREATE TABLE IF NOT EXISTS DM_DEVICE_APPLICATION_MAPPING (
ID INTEGER AUTO_INCREMENT NOT NULL,
DEVICE_ID INTEGER NOT NULL,
APPLICATION_ID INTEGER NOT NULL,
TENANT_ID INTEGER NOT NULL,
PRIMARY KEY (ID),
CONSTRAINT fk_dm_device FOREIGN KEY (DEVICE_ID) REFERENCES
DM_DEVICE (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
CONSTRAINT fk_dm_application FOREIGN KEY (APPLICATION_ID) REFERENCES
DM_APPLICATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
);
-- POLICY RELATED TABLES FINISHED --
-- NOTIFICATION TABLE --
CREATE TABLE IF NOT EXISTS DM_NOTIFICATION (
NOTIFICATION_ID INTEGER AUTO_INCREMENT NOT NULL,
DEVICE_ID INTEGER NOT NULL,
OPERATION_ID INTEGER NOT NULL,
TENANT_ID INTEGER NOT NULL,
STATUS VARCHAR(10) NULL,
DESCRIPTION VARCHAR(1000) NULL,
PRIMARY KEY (NOTIFICATION_ID),
CONSTRAINT fk_dm_device_notification FOREIGN KEY (DEVICE_ID) REFERENCES
DM_DEVICE (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
CONSTRAINT fk_dm_operation_notification FOREIGN KEY (OPERATION_ID) REFERENCES
DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
);
-- NOTIFICATION TABLE END --
CREATE TABLE IF NOT EXISTS DM_DEVICE_INFO (
ID INTEGER AUTO_INCREMENT NOT NULL,
DEVICE_ID INT NULL,
KEY_FIELD VARCHAR(45) NULL,
VALUE_FIELD VARCHAR(100) NULL,
PRIMARY KEY (ID),
CONSTRAINT DM_DEVICE_INFO_DEVICE
FOREIGN KEY (DEVICE_ID)
REFERENCES DM_DEVICE (ID)
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_DEVICE_LOCATION (
ID INTEGER AUTO_INCREMENT NOT NULL,
DEVICE_ID INT NULL,
LATITUDE DOUBLE NULL,
LONGITUDE DOUBLE NULL,
STREET1 VARCHAR(255) NULL,
STREET2 VARCHAR(45) NULL,
CITY VARCHAR(45) NULL,
ZIP VARCHAR(10) NULL,
STATE VARCHAR(45) NULL,
COUNTRY VARCHAR(45) NULL,
UPDATE_TIMESTAMP BIGINT(15) NOT NULL,
PRIMARY KEY (ID),
CONSTRAINT DM_DEVICE_LOCATION_DEVICE
FOREIGN KEY (DEVICE_ID)
REFERENCES DM_DEVICE (ID)
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
CREATE TABLE IF NOT EXISTS DM_DEVICE_DETAIL (
ID INT NOT NULL AUTO_INCREMENT,
DEVICE_ID INT NOT NULL,
DEVICE_MODEL VARCHAR(45) NULL,
VENDOR VARCHAR(45) NULL,
OS_VERSION VARCHAR(45) NULL,
OS_BUILD_DATE VARCHAR(100) NULL,
BATTERY_LEVEL DECIMAL(4) NULL,
INTERNAL_TOTAL_MEMORY DECIMAL(30,3) NULL,
INTERNAL_AVAILABLE_MEMORY DECIMAL(30,3) NULL,
EXTERNAL_TOTAL_MEMORY DECIMAL(30,3) NULL,
EXTERNAL_AVAILABLE_MEMORY DECIMAL(30,3) NULL,
CONNECTION_TYPE VARCHAR(50) NULL,
SSID VARCHAR(45) NULL,
CPU_USAGE DECIMAL(5) NULL,
TOTAL_RAM_MEMORY DECIMAL(30,3) NULL,
AVAILABLE_RAM_MEMORY DECIMAL(30,3) NULL,
PLUGGED_IN INT(1) NULL,
UPDATE_TIMESTAMP BIGINT(15) NOT NULL,
PRIMARY KEY (ID),
CONSTRAINT FK_DM_DEVICE_DETAILS_DEVICE
FOREIGN KEY (DEVICE_ID)
REFERENCES DM_DEVICE (ID)
ON DELETE NO ACTION
ON UPDATE NO ACTION
);
-- POLICY AND DEVICE GROUP MAPPING --
CREATE TABLE IF NOT EXISTS DM_DEVICE_GROUP_POLICY (
ID INT NOT NULL AUTO_INCREMENT,
DEVICE_GROUP_ID INT NOT NULL,
POLICY_ID INT NOT NULL,
TENANT_ID INT NOT NULL,
PRIMARY KEY (ID),
CONSTRAINT FK_DM_DEVICE_GROUP_POLICY
FOREIGN KEY (DEVICE_GROUP_ID)
REFERENCES DM_GROUP (ID)
ON DELETE CASCADE
ON UPDATE CASCADE ,
CONSTRAINT FK_DM_DEVICE_GROUP_DM_POLICY
FOREIGN KEY (POLICY_ID)
REFERENCES DM_POLICY (ID)
ON DELETE CASCADE
ON UPDATE CASCADE
);
-- END OF POLICY AND DEVICE GROUP MAPPING --
-- DASHBOARD RELATED VIEWS --
CREATE VIEW POLICY_COMPLIANCE_INFO AS
SELECT
DEVICE_INFO.DEVICE_ID,
DEVICE_INFO.DEVICE_IDENTIFICATION,
DEVICE_INFO.PLATFORM,
DEVICE_INFO.OWNERSHIP,
DEVICE_INFO.CONNECTIVITY_STATUS,
IFNULL(DEVICE_WITH_POLICY_INFO.POLICY_ID, -1) AS POLICY_ID,
IFNULL(DEVICE_WITH_POLICY_INFO.IS_COMPLIANT, -1) AS IS_COMPLIANT,
DEVICE_INFO.TENANT_ID
FROM
(SELECT
DM_DEVICE.ID AS DEVICE_ID,
DM_DEVICE.DEVICE_IDENTIFICATION,
DM_DEVICE_TYPE.NAME AS PLATFORM,
DM_ENROLMENT.OWNERSHIP,
DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS,
DM_DEVICE.TENANT_ID
FROM DM_DEVICE, DM_DEVICE_TYPE, DM_ENROLMENT
WHERE DM_DEVICE.DEVICE_TYPE_ID = DM_DEVICE_TYPE.ID AND DM_DEVICE.ID = DM_ENROLMENT.DEVICE_ID) DEVICE_INFO
LEFT JOIN
(SELECT
DEVICE_ID,
POLICY_ID,
STATUS AS IS_COMPLIANT
FROM DM_POLICY_COMPLIANCE_STATUS) DEVICE_WITH_POLICY_INFO
ON DEVICE_INFO.DEVICE_ID = DEVICE_WITH_POLICY_INFO.DEVICE_ID
ORDER BY DEVICE_INFO.DEVICE_ID;
CREATE VIEW FEATURE_NON_COMPLIANCE_INFO AS
SELECT
DM_DEVICE.ID AS DEVICE_ID,
DM_DEVICE.DEVICE_IDENTIFICATION,
DM_DEVICE_DETAIL.DEVICE_MODEL,
DM_DEVICE_DETAIL.VENDOR,
DM_DEVICE_DETAIL.OS_VERSION,
DM_ENROLMENT.OWNERSHIP,
DM_ENROLMENT.OWNER,
DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS,
DM_POLICY_COMPLIANCE_STATUS.POLICY_ID,
DM_DEVICE_TYPE.NAME AS PLATFORM,
DM_POLICY_COMPLIANCE_FEATURES.FEATURE_CODE,
DM_POLICY_COMPLIANCE_FEATURES.STATUS AS IS_COMPLAINT,
DM_DEVICE.TENANT_ID
FROM
DM_POLICY_COMPLIANCE_FEATURES, DM_POLICY_COMPLIANCE_STATUS, DM_ENROLMENT, DM_DEVICE, DM_DEVICE_TYPE, DM_DEVICE_DETAIL
WHERE
DM_POLICY_COMPLIANCE_FEATURES.COMPLIANCE_STATUS_ID = DM_POLICY_COMPLIANCE_STATUS.ID AND
DM_POLICY_COMPLIANCE_STATUS.ENROLMENT_ID = DM_ENROLMENT.ID AND
DM_POLICY_COMPLIANCE_STATUS.DEVICE_ID = DM_DEVICE.ID AND
DM_DEVICE.DEVICE_TYPE_ID = DM_DEVICE_TYPE.ID AND
DM_DEVICE.ID = DM_DEVICE_DETAIL.DEVICE_ID
ORDER BY TENANT_ID, DEVICE_ID;
-- END OF DASHBOARD RELATED VIEWS --
Loading…
Cancel
Save