code conflicts

revert-70aa11f8
hasuniea 9 years ago
commit e4dfe63548

@ -293,6 +293,19 @@ public class CertificateGenerator {
return lookUpCertificate; return lookUpCertificate;
} }
public CertificateResponse verifyCertificateDN(String distinguishedName) throws KeystoreException {
CertificateResponse lookUpCertificate = null;
KeyStoreReader keyStoreReader = new KeyStoreReader();
if (distinguishedName != null && !distinguishedName.isEmpty()) {
String[] dnSplits = distinguishedName.split("/CN=");
if (dnSplits != null) {
String commonNameExtracted = dnSplits[dnSplits.length-1];
lookUpCertificate = keyStoreReader.getCertificateBySerial(commonNameExtracted);
}
}
return lookUpCertificate;
}
public static String getCommonName(X509Certificate requestCertificate) { public static String getCommonName(X509Certificate requestCertificate) {
String distinguishedName = requestCertificate.getSubjectDN().getName(); String distinguishedName = requestCertificate.getSubjectDN().getName();
if (distinguishedName != null && !distinguishedName.isEmpty()) { if (distinguishedName != null && !distinguishedName.isEmpty()) {

@ -56,6 +56,8 @@ public interface CertificateManagementService {
public CertificateResponse verifyPEMSignature(X509Certificate requestCertificate) throws KeystoreException; public CertificateResponse verifyPEMSignature(X509Certificate requestCertificate) throws KeystoreException;
public CertificateResponse verifySubjectDN(String requestDN) throws KeystoreException;
public X509Certificate extractCertificateFromSignature(String headerSignature) throws KeystoreException; public X509Certificate extractCertificateFromSignature(String headerSignature) throws KeystoreException;
String extractChallengeToken(X509Certificate certificate); String extractChallengeToken(X509Certificate certificate);

@ -108,6 +108,10 @@ public class CertificateManagementServiceImpl implements CertificateManagementSe
return certificateGenerator.verifyPEMSignature(requestCertificate); return certificateGenerator.verifyPEMSignature(requestCertificate);
} }
@Override public CertificateResponse verifySubjectDN(String requestDN) throws KeystoreException {
return certificateGenerator.verifyCertificateDN(requestDN);
}
public X509Certificate extractCertificateFromSignature(String headerSignature) throws KeystoreException { public X509Certificate extractCertificateFromSignature(String headerSignature) throws KeystoreException {
return certificateGenerator.extractCertificateFromSignature(headerSignature); return certificateGenerator.extractCertificateFromSignature(headerSignature);
} }

@ -485,7 +485,8 @@ public abstract class AbstractGadgetDataServiceDAO implements GadgetDataServiceD
try { try {
con = this.getConnection(); con = this.getConnection();
String sql; String sql;
sql = "SELECT DEVICE_ID, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM DEVICES_VIEW_1 WHERE TENANT_ID = ?"; sql = "SELECT DEVICE_ID, DEVICE_IDENTIFICATION, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM " +
"DEVICES_VIEW_1 WHERE TENANT_ID = ?";
// appending filters to support advanced filtering options // appending filters to support advanced filtering options
// [1] appending filter columns, if exist // [1] appending filter columns, if exist
if (filters != null && filters.size() > 0) { if (filters != null && filters.size() > 0) {
@ -514,6 +515,7 @@ public abstract class AbstractGadgetDataServiceDAO implements GadgetDataServiceD
while (rs.next()) { while (rs.next()) {
filteredDeviceWithDetails = new DetailedDeviceEntry(); filteredDeviceWithDetails = new DetailedDeviceEntry();
filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID")); filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
filteredDeviceWithDetails.setDeviceIdentification(rs.getString("DEVICE_IDENTIFICATION"));
filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM")); filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP")); filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS")); filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));
@ -543,8 +545,8 @@ public abstract class AbstractGadgetDataServiceDAO implements GadgetDataServiceD
try { try {
con = this.getConnection(); con = this.getConnection();
String sql; String sql;
sql = "SELECT DEVICE_ID, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM DEVICES_VIEW_2 " + sql = "SELECT DEVICE_ID, DEVICE_IDENTIFICATION, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM " +
"WHERE TENANT_ID = ? AND FEATURE_CODE = ?"; "DEVICES_VIEW_2 WHERE TENANT_ID = ? AND FEATURE_CODE = ?";
// appending filters to support advanced filtering options // appending filters to support advanced filtering options
// [1] appending filter columns, if exist // [1] appending filter columns, if exist
if (filters != null && filters.size() > 0) { if (filters != null && filters.size() > 0) {
@ -574,6 +576,7 @@ public abstract class AbstractGadgetDataServiceDAO implements GadgetDataServiceD
while (rs.next()) { while (rs.next()) {
filteredDeviceWithDetails = new DetailedDeviceEntry(); filteredDeviceWithDetails = new DetailedDeviceEntry();
filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID")); filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
filteredDeviceWithDetails.setDeviceIdentification(rs.getString("DEVICE_IDENTIFICATION"));
filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM")); filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP")); filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS")); filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));

@ -21,6 +21,7 @@ package org.wso2.carbon.device.mgt.analytics.dashboard.dao.bean;
public class DetailedDeviceEntry { public class DetailedDeviceEntry {
private int deviceId; private int deviceId;
private String deviceIdentification;
private String platform; private String platform;
private String ownershipType; private String ownershipType;
private String connectivityStatus; private String connectivityStatus;
@ -34,6 +35,15 @@ public class DetailedDeviceEntry {
this.deviceId = deviceId; this.deviceId = deviceId;
} }
@SuppressWarnings("unused")
public String getDeviceIdentification() {
return deviceIdentification;
}
public void setDeviceIdentification(String deviceIdentification) {
this.deviceIdentification = deviceIdentification;
}
@SuppressWarnings("unused") @SuppressWarnings("unused")
public String getPlatform() { public String getPlatform() {
return platform; return platform;

@ -127,8 +127,8 @@ public class GenericGadgetDataServiceDAOImpl extends AbstractGadgetDataServiceDA
advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? "; advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? ";
} }
} }
sql = "SELECT DEVICE_ID, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM DEVICES_VIEW_1 " + sql = "SELECT DEVICE_ID, DEVICE_IDENTIFICATION, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM " +
"WHERE TENANT_ID = ? " + advancedSqlFiltering + "ORDER BY DEVICE_ID ASC LIMIT ?, ?"; "DEVICES_VIEW_1 WHERE TENANT_ID = ? " + advancedSqlFiltering + "ORDER BY DEVICE_ID ASC LIMIT ?, ?";
stmt = con.prepareStatement(sql); stmt = con.prepareStatement(sql);
// [2] appending filter column values, if exist // [2] appending filter column values, if exist
stmt.setInt(1, tenantId); stmt.setInt(1, tenantId);
@ -155,6 +155,7 @@ public class GenericGadgetDataServiceDAOImpl extends AbstractGadgetDataServiceDA
while (rs.next()) { while (rs.next()) {
filteredDeviceWithDetails = new DetailedDeviceEntry(); filteredDeviceWithDetails = new DetailedDeviceEntry();
filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID")); filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
filteredDeviceWithDetails.setDeviceIdentification(rs.getString("DEVICE_IDENTIFICATION"));
filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM")); filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP")); filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS")); filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));
@ -217,8 +218,8 @@ public class GenericGadgetDataServiceDAOImpl extends AbstractGadgetDataServiceDA
advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? "; advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? ";
} }
} }
sql = "SELECT DEVICE_ID, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM DEVICES_VIEW_2 " + sql = "SELECT DEVICE_ID, DEVICE_IDENTIFICATION, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM " +
"WHERE TENANT_ID = ? AND FEATURE_CODE = ? " + advancedSqlFiltering + "DEVICES_VIEW_2 WHERE TENANT_ID = ? AND FEATURE_CODE = ? " + advancedSqlFiltering +
"ORDER BY DEVICE_ID ASC LIMIT ?, ?"; "ORDER BY DEVICE_ID ASC LIMIT ?, ?";
stmt = con.prepareStatement(sql); stmt = con.prepareStatement(sql);
// [2] appending filter column values, if exist // [2] appending filter column values, if exist
@ -247,6 +248,7 @@ public class GenericGadgetDataServiceDAOImpl extends AbstractGadgetDataServiceDA
while (rs.next()) { while (rs.next()) {
filteredDeviceWithDetails = new DetailedDeviceEntry(); filteredDeviceWithDetails = new DetailedDeviceEntry();
filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID")); filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
filteredDeviceWithDetails.setDeviceIdentification(rs.getString("DEVICE_IDENTIFICATION"));
filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM")); filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP")); filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS")); filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));

@ -128,8 +128,8 @@ public class MSSQLGadgetDataServiceDAOImpl extends AbstractGadgetDataServiceDAO
advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? "; advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? ";
} }
} }
sql = "SELECT DEVICE_ID, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM DEVICES_VIEW_1 " + sql = "SELECT DEVICE_ID, DEVICE_IDENTIFICATION, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM " +
"WHERE TENANT_ID = ? " + advancedSqlFiltering + "ORDER BY DEVICE_ID ASC " + "DEVICES_VIEW_1 WHERE TENANT_ID = ? " + advancedSqlFiltering + "ORDER BY DEVICE_ID ASC " +
"OFFSET ? ROWS FETCH NEXT ? ROWS ONLY"; "OFFSET ? ROWS FETCH NEXT ? ROWS ONLY";
stmt = con.prepareStatement(sql); stmt = con.prepareStatement(sql);
// [2] appending filter column values, if exist // [2] appending filter column values, if exist
@ -157,6 +157,7 @@ public class MSSQLGadgetDataServiceDAOImpl extends AbstractGadgetDataServiceDAO
while (rs.next()) { while (rs.next()) {
filteredDeviceWithDetails = new DetailedDeviceEntry(); filteredDeviceWithDetails = new DetailedDeviceEntry();
filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID")); filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
filteredDeviceWithDetails.setDeviceIdentification(rs.getString("DEVICE_IDENTIFICATION"));
filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM")); filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP")); filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS")); filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));
@ -219,8 +220,8 @@ public class MSSQLGadgetDataServiceDAOImpl extends AbstractGadgetDataServiceDAO
advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? "; advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? ";
} }
} }
sql = "SELECT DEVICE_ID, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM DEVICES_VIEW_2 " + sql = "SELECT DEVICE_ID, DEVICE_IDENTIFICATION, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM " +
"WHERE TENANT_ID = ? AND FEATURE_CODE = ? " + advancedSqlFiltering + "DEVICES_VIEW_2 WHERE TENANT_ID = ? AND FEATURE_CODE = ? " + advancedSqlFiltering +
"ORDER BY DEVICE_ID ASC OFFSET ? ROWS FETCH NEXT ? ROWS ONLY"; "ORDER BY DEVICE_ID ASC OFFSET ? ROWS FETCH NEXT ? ROWS ONLY";
stmt = con.prepareStatement(sql); stmt = con.prepareStatement(sql);
// [2] appending filter column values, if exist // [2] appending filter column values, if exist
@ -249,6 +250,7 @@ public class MSSQLGadgetDataServiceDAOImpl extends AbstractGadgetDataServiceDAO
while (rs.next()) { while (rs.next()) {
filteredDeviceWithDetails = new DetailedDeviceEntry(); filteredDeviceWithDetails = new DetailedDeviceEntry();
filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID")); filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
filteredDeviceWithDetails.setDeviceIdentification(rs.getString("DEVICE_IDENTIFICATION"));
filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM")); filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP")); filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS")); filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));

@ -78,7 +78,7 @@ public class OracleGadgetDataServiceDAOImpl extends AbstractGadgetDataServiceDAO
} }
// fetching total records count // fetching total records count
sql = "SELECT COUNT(FEATURE_CODE) AS NON_COMPLIANT_FEATURE_COUNT FROM " + sql = "SELECT COUNT(FEATURE_CODE) AS NON_COMPLIANT_FEATURE_COUNT FROM " +
"(SELECT DISTINCT FEATURE_CODE FROM DEVICES_VIEW_2 WHERE TENANT_ID = ?) NON_COMPLIANT_FEATURE_CODE"; "(SELECT DISTINCT FEATURE_CODE FROM DEVICES_VIEW_2 WHERE TENANT_ID = ?) NON_COMPLIANT_FEATURE_CODE";
stmt = con.prepareStatement(sql); stmt = con.prepareStatement(sql);
stmt.setInt(1, tenantId); stmt.setInt(1, tenantId);
@ -128,8 +128,8 @@ public class OracleGadgetDataServiceDAOImpl extends AbstractGadgetDataServiceDAO
advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? "; advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? ";
} }
} }
sql = "SELECT * FROM (SELECT ROWNUM offset, rs.* FROM (SELECT DEVICE_ID, PLATFORM, OWNERSHIP, " + sql = "SELECT * FROM (SELECT ROWNUM offset, rs.* FROM (SELECT DEVICE_ID, DEVICE_IDENTIFICATION, PLATFORM, " +
"CONNECTIVITY_STATUS FROM DEVICES_VIEW_1 WHERE TENANT_ID = ? " + advancedSqlFiltering + "OWNERSHIP, CONNECTIVITY_STATUS FROM DEVICES_VIEW_1 WHERE TENANT_ID = ? " + advancedSqlFiltering +
"ORDER BY DEVICE_ID ASC) rs) WHERE offset >= ? AND ROWNUM <= ?"; "ORDER BY DEVICE_ID ASC) rs) WHERE offset >= ? AND ROWNUM <= ?";
stmt = con.prepareStatement(sql); stmt = con.prepareStatement(sql);
// [2] appending filter column values, if exist // [2] appending filter column values, if exist
@ -157,6 +157,7 @@ public class OracleGadgetDataServiceDAOImpl extends AbstractGadgetDataServiceDAO
while (rs.next()) { while (rs.next()) {
filteredDeviceWithDetails = new DetailedDeviceEntry(); filteredDeviceWithDetails = new DetailedDeviceEntry();
filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID")); filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
filteredDeviceWithDetails.setDeviceIdentification(rs.getString("DEVICE_IDENTIFICATION"));
filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM")); filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP")); filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS")); filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));
@ -219,8 +220,8 @@ public class OracleGadgetDataServiceDAOImpl extends AbstractGadgetDataServiceDAO
advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? "; advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? ";
} }
} }
sql = "SELECT * FROM (SELECT ROWNUM offset, rs.* FROM (SELECT DEVICE_ID, PLATFORM, OWNERSHIP, " + sql = "SELECT * FROM (SELECT ROWNUM offset, rs.* FROM (SELECT DEVICE_ID, DEVICE_IDENTIFICATION, PLATFORM, " +
"CONNECTIVITY_STATUS FROM DEVICES_VIEW_2 WHERE TENANT_ID = ? AND FEATURE_CODE = ? " + "OWNERSHIP, CONNECTIVITY_STATUS FROM DEVICES_VIEW_2 WHERE TENANT_ID = ? AND FEATURE_CODE = ? " +
advancedSqlFiltering + "ORDER BY DEVICE_ID ASC) rs) WHERE offset >= ? AND ROWNUM <= ?"; advancedSqlFiltering + "ORDER BY DEVICE_ID ASC) rs) WHERE offset >= ? AND ROWNUM <= ?";
stmt = con.prepareStatement(sql); stmt = con.prepareStatement(sql);
// [2] appending filter column values, if exist // [2] appending filter column values, if exist
@ -249,6 +250,7 @@ public class OracleGadgetDataServiceDAOImpl extends AbstractGadgetDataServiceDAO
while (rs.next()) { while (rs.next()) {
filteredDeviceWithDetails = new DetailedDeviceEntry(); filteredDeviceWithDetails = new DetailedDeviceEntry();
filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID")); filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
filteredDeviceWithDetails.setDeviceIdentification(rs.getString("DEVICE_IDENTIFICATION"));
filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM")); filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP")); filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS")); filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));

@ -127,8 +127,8 @@ public class PostgreSQLGadgetDataServiceDAOImpl extends AbstractGadgetDataServic
advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? "; advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? ";
} }
} }
sql = "SELECT DEVICE_ID, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM DEVICES_VIEW_1 " + sql = "SELECT DEVICE_ID, DEVICE_IDENTIFICATION, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM " +
"WHERE TENANT_ID = ? " + advancedSqlFiltering + "ORDER BY DEVICE_ID ASC OFFSET ? LIMIT ?"; "DEVICES_VIEW_1 WHERE TENANT_ID = ? " + advancedSqlFiltering + "ORDER BY DEVICE_ID ASC OFFSET ? LIMIT ?";
stmt = con.prepareStatement(sql); stmt = con.prepareStatement(sql);
// [2] appending filter column values, if exist // [2] appending filter column values, if exist
stmt.setInt(1, tenantId); stmt.setInt(1, tenantId);
@ -155,6 +155,7 @@ public class PostgreSQLGadgetDataServiceDAOImpl extends AbstractGadgetDataServic
while (rs.next()) { while (rs.next()) {
filteredDeviceWithDetails = new DetailedDeviceEntry(); filteredDeviceWithDetails = new DetailedDeviceEntry();
filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID")); filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
filteredDeviceWithDetails.setDeviceIdentification(rs.getString("DEVICE_IDENTIFICATION"));
filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM")); filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP")); filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS")); filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));
@ -217,8 +218,8 @@ public class PostgreSQLGadgetDataServiceDAOImpl extends AbstractGadgetDataServic
advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? "; advancedSqlFiltering = advancedSqlFiltering + "AND " + column + " = ? ";
} }
} }
sql = "SELECT DEVICE_ID, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM DEVICES_VIEW_2 " + sql = "SELECT DEVICE_ID, DEVICE_IDENTIFICATION, PLATFORM, OWNERSHIP, CONNECTIVITY_STATUS FROM " +
"WHERE TENANT_ID = ? AND FEATURE_CODE = ? " + advancedSqlFiltering + "DEVICES_VIEW_2 WHERE TENANT_ID = ? AND FEATURE_CODE = ? " + advancedSqlFiltering +
"ORDER BY DEVICE_ID ASC OFFSET ? LIMIT ?"; "ORDER BY DEVICE_ID ASC OFFSET ? LIMIT ?";
stmt = con.prepareStatement(sql); stmt = con.prepareStatement(sql);
// [2] appending filter column values, if exist // [2] appending filter column values, if exist
@ -247,6 +248,7 @@ public class PostgreSQLGadgetDataServiceDAOImpl extends AbstractGadgetDataServic
while (rs.next()) { while (rs.next()) {
filteredDeviceWithDetails = new DetailedDeviceEntry(); filteredDeviceWithDetails = new DetailedDeviceEntry();
filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID")); filteredDeviceWithDetails.setDeviceId(rs.getInt("DEVICE_ID"));
filteredDeviceWithDetails.setDeviceIdentification(rs.getString("DEVICE_IDENTIFICATION"));
filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM")); filteredDeviceWithDetails.setPlatform(rs.getString("PLATFORM"));
filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP")); filteredDeviceWithDetails.setOwnershipType(rs.getString("OWNERSHIP"));
filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS")); filteredDeviceWithDetails.setConnectivityStatus(rs.getString("CONNECTIVITY_STATUS"));

@ -83,7 +83,7 @@ public class DeviceDataPublisher {
* *
*/ */
public DataPublisher getDataPublisher() throws DataPublisherConfigurationException { public DataPublisher getDataPublisher() throws DataPublisherConfigurationException {
String tenantDomain = CarbonContext.getThreadLocalCarbonContext().getTenantDomain(); String tenantDomain = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantDomain(true);
//Get LoadBalancingDataPublisher which has been registered for the tenant. //Get LoadBalancingDataPublisher which has been registered for the tenant.
DataPublisher dataPublisher = getDataPublisher(tenantDomain); DataPublisher dataPublisher = getDataPublisher(tenantDomain);
//If a LoadBalancingDataPublisher had not been registered for the tenant. //If a LoadBalancingDataPublisher had not been registered for the tenant.

@ -18,19 +18,17 @@
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.logging.Log; import io.swagger.annotations.Api;
import org.apache.commons.logging.LogFactory;
import javax.ws.rs.Consumes; import javax.ws.rs.Consumes;
import javax.ws.rs.Produces; import javax.ws.rs.Produces;
/** /**
* Authentication related REST-API implementation. * Authentication related REST-API interface.
*/ */
@Api(value = "Authentication")
@Produces({ "application/json", "application/xml" }) @Produces({ "application/json", "application/xml" })
@Consumes({ "application/json", "application/xml" }) @Consumes({ "application/json", "application/xml" })
public class Authentication { public interface Authentication {
private static Log log = LogFactory.getLog(Authentication.class);
} }

@ -18,43 +18,29 @@
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.logging.Log; import io.swagger.annotations.Api;
import org.apache.commons.logging.LogFactory; import io.swagger.annotations.ApiOperation;
import org.wso2.carbon.certificate.mgt.core.dao.CertificateManagementDAOException; import io.swagger.annotations.ApiParam;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import org.wso2.carbon.certificate.mgt.core.dto.CertificateResponse; import org.wso2.carbon.certificate.mgt.core.dto.CertificateResponse;
import org.wso2.carbon.certificate.mgt.core.exception.KeystoreException;
import org.wso2.carbon.certificate.mgt.core.service.CertificateManagementService;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException;
import org.wso2.carbon.device.mgt.common.PaginationRequest;
import org.wso2.carbon.device.mgt.common.PaginationResult; import org.wso2.carbon.device.mgt.common.PaginationResult;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils; import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.device.mgt.jaxrs.beans.EnrollmentCertificate; import org.wso2.carbon.device.mgt.jaxrs.beans.EnrollmentCertificate;
import org.wso2.carbon.device.mgt.jaxrs.exception.Message;
import javax.ws.rs.Consumes; import javax.ws.rs.*;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.HeaderParam;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
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.util.ArrayList;
import java.util.List;
/** /**
* All the certificate related tasks such as saving certificates, can be done through this endpoint. * All the certificate related tasks such as saving certificates, can be done through this endpoint.
*/ */
@Api(value = "Certificate", description = "certificate related tasks such as saving certificates")
@SuppressWarnings("NonJaxWsWebServices") @SuppressWarnings("NonJaxWsWebServices")
@Produces({"application/json", "application/xml"}) @Produces({ "application/json", "application/xml" })
@Consumes({ "application/json", "application/xml" }) @Consumes({ "application/json", "application/xml" })
public class Certificate { public interface Certificate {
private static Log log = LogFactory.getLog(Operation.class);
/** /**
* Save a list of certificates and relevant information in the database. * Save a list of certificates and relevant information in the database.
@ -65,30 +51,21 @@ public class Certificate {
*/ */
@POST @POST
@Path("saveCertificate") @Path("saveCertificate")
public Response saveCertificate(@HeaderParam("Accept") String acceptHeader, @ApiOperation(
EnrollmentCertificate[] enrollmentCertificates) { consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
MediaType responseMediaType = DeviceMgtAPIUtils.getResponseMediaType(acceptHeader); produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
CertificateManagementService certificateService; httpMethod = "POST",
List<org.wso2.carbon.certificate.mgt.core.bean.Certificate> certificates = new ArrayList<>(); value = "Adding an SSL Certificate",
org.wso2.carbon.certificate.mgt.core.bean.Certificate certificate; notes = "Add a new SSL certificate to the client end database",
certificateService = DeviceMgtAPIUtils.getCertificateManagementService(); response = MediaType.class)
try { @ApiResponses(value = {
for (EnrollmentCertificate enrollmentCertificate : enrollmentCertificates) { @ApiResponse(code = 200, message = "Added successfully"),
certificate = new org.wso2.carbon.certificate.mgt.core.bean.Certificate(); @ApiResponse(code = 500, message = "Error occurred while saving the certificate")
certificate.setTenantId(PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId()); })
certificate.setSerial(enrollmentCertificate.getSerial()); Response saveCertificate(@HeaderParam("Accept") String acceptHeader,
certificate.setCertificate(certificateService.pemToX509Certificate(enrollmentCertificate.getPem())); @ApiParam(name = "enrollmentCertificates", value = "certificate with serial, "
certificates.add(certificate); + "pem and tenant id", required = true) EnrollmentCertificate[]
} enrollmentCertificates);
certificateService.saveCertificate(certificates);
return Response.status(Response.Status.CREATED).entity("Added successfully.").
type(responseMediaType).build();
} catch (KeystoreException e) {
String msg = "Error occurred while converting PEM file to X509Certificate.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).type(responseMediaType).build();
}
}
/** /**
* Get a certificate when the serial number is given. * Get a certificate when the serial number is given.
@ -98,31 +75,22 @@ public class Certificate {
*/ */
@GET @GET
@Path("{serialNumber}") @Path("{serialNumber}")
public Response getCertificate(@HeaderParam("Accept") String acceptHeader, @ApiOperation(
@PathParam("serialNumber") String serialNumber) { consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
MediaType responseMediaType = DeviceMgtAPIUtils.getResponseMediaType(acceptHeader); produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
Message message = new Message(); httpMethod = "GET",
value = "Getting Details of an SSL Certificate",
if (serialNumber == null || serialNumber.isEmpty()) { notes = "Get the client side SSL certificate details",
message.setErrorMessage("Invalid serial number"); response = CertificateResponse.class)
message.setDiscription("Serial number is missing or invalid."); @ApiResponses(value = {
return Response.status(Response.Status.BAD_REQUEST).entity(message).type(responseMediaType).build(); @ApiResponse(code = 200, message = "OK"),
} @ApiResponse(code = 400, message = "Notification status updated successfully"),
@ApiResponse(code = 500, message = "Error occurred while converting PEM file to X509Certificate")
CertificateManagementService certificateService = DeviceMgtAPIUtils.getCertificateManagementService(); })
CertificateResponse certificateResponse; Response getCertificate(@HeaderParam("Accept") String acceptHeader,
try { @ApiParam(name = "serialNumber", value = "Provide the serial number of the "
certificateResponse = certificateService.getCertificateBySerial(serialNumber); + "certificate that you wish to get the details of", required = true)
if(certificateResponse != null) { @PathParam("serialNumber") String serialNumber);
certificateResponse.setCertificate(null); //avoid sending byte array in response.
}
return Response.status(Response.Status.OK).entity(certificateResponse).type(responseMediaType).build();
} catch (KeystoreException e) {
String msg = "Error occurred while converting PEM file to X509Certificate";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).type(responseMediaType).build();
}
}
/** /**
* Get all certificates in a paginated manner. * Get all certificates in a paginated manner.
@ -134,61 +102,46 @@ public class Certificate {
*/ */
@GET @GET
@Path("paginate") @Path("paginate")
public Response getAllCertificates(@HeaderParam("Accept") String acceptHeader, @ApiOperation(
@QueryParam("start") int startIndex, consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
@QueryParam("length") int length) produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
throws MDMAPIException { httpMethod = "GET",
MediaType responseMediaType = DeviceMgtAPIUtils.getResponseMediaType(acceptHeader); value = "Getting the Certificate Details in a Paginated Manner",
Message message = new Message(); notes = "You will have many certificates used for mutual SSL. In a situation where you wish to "
+ "view all the certificate details, it is not feasible to show all the details on one "
if (startIndex < 0) { + "page therefore the details are paginated",
message.setErrorMessage("Invalid start index."); response = PaginationResult.class)
message.setDiscription("Start index cannot be less that 0."); @ApiResponses(value = {
return Response.status(Response.Status.BAD_REQUEST).entity(message).type(responseMediaType).build(); @ApiResponse(code = 200, message = "OK"),
} else if (length <= 0) { @ApiResponse(code = 400, message = "Invalid start index"),
message.setErrorMessage("Invalid length value."); @ApiResponse(code = 400, message = "Invalid length value"),
message.setDiscription("Length should be a positive integer."); @ApiResponse(code = 500, message = "Error occurred while fetching all certificates")
return Response.status(Response.Status.BAD_REQUEST).entity(message).type(responseMediaType).build(); })
} Response getAllCertificates(@HeaderParam("Accept") String acceptHeader,
@ApiParam(name = "start",
CertificateManagementService certificateService = DeviceMgtAPIUtils.getCertificateManagementService(); value = "Provide the starting pagination index as the value", required = true)
PaginationRequest paginationRequest = new PaginationRequest(startIndex, length); @QueryParam("start") int startIndex,
try { @ApiParam(name = "length", value = "Provide how many certificate details you"
PaginationResult certificates = certificateService.getAllCertificates(paginationRequest); + " require from the starting pagination index as the value",
return Response.status(Response.Status.OK).entity(certificates).type(responseMediaType).build(); required = true) @QueryParam("length") int length) throws MDMAPIException;
} catch (CertificateManagementDAOException e) {
String msg = "Error occurred while fetching all certificates.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).type(responseMediaType).build();
}
}
@DELETE @DELETE
@Path("{serialNumber}") @Path("{serialNumber}")
public Response removeCertificate(@HeaderParam("Accept") String acceptHeader, @ApiOperation(
@PathParam("serialNumber") String serialNumber) throws MDMAPIException { consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
MediaType responseMediaType = DeviceMgtAPIUtils.getResponseMediaType(acceptHeader); produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
Message message = new Message(); httpMethod = "DELETE",
value = "Deleting an SSL Certificate",
if (serialNumber == null || serialNumber.isEmpty()) { notes = "Delete an SSL certificate that's on the client end",
message.setErrorMessage("Invalid serial number"); response = boolean.class)
message.setDiscription("Serial number is missing or invalid."); @ApiResponses(value = {
return Response.status(Response.Status.BAD_REQUEST).entity(message).type(responseMediaType).build(); @ApiResponse(code = 200, message = "OK"),
} @ApiResponse(code = 400, message = "Invalid start index"),
@ApiResponse(code = 500, message = "Error when deleting the certificate"
) })
Response removeCertificate(@HeaderParam("Accept") String acceptHeader,
@ApiParam(name = "serialNumber", value = "Provide the serial number of the "
+ "certificate that you wish to delete", required = true)
@PathParam("serialNumber") String serialNumber) throws MDMAPIException;
CertificateManagementService certificateService = DeviceMgtAPIUtils.getCertificateManagementService();
boolean deleted;
try {
deleted = certificateService.removeCertificate(serialNumber);
if(deleted){
return Response.status(Response.Status.OK).entity(deleted).type(responseMediaType).build();
} else {
return Response.status(Response.Status.GONE).entity(deleted).type(responseMediaType).build();
}
} catch (CertificateManagementDAOException e) {
String msg = "Error occurred while converting PEM file to X509Certificate";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).type(responseMediaType).build();
}
}
} }

@ -18,96 +18,72 @@
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.httpclient.HttpStatus; import io.swagger.annotations.Api;
import org.apache.commons.logging.Log; import io.swagger.annotations.ApiOperation;
import org.apache.commons.logging.LogFactory; import io.swagger.annotations.ApiParam;
import org.wso2.carbon.device.mgt.common.configuration.mgt.ConfigurationEntry; import io.swagger.annotations.ApiResponse;
import org.wso2.carbon.device.mgt.common.configuration.mgt.ConfigurationManagementException; import io.swagger.annotations.ApiResponses;
import org.wso2.carbon.device.mgt.common.configuration.mgt.TenantConfiguration; import org.wso2.carbon.device.mgt.common.configuration.mgt.TenantConfiguration;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.api.util.MDMAppConstants;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload; import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.policy.mgt.core.util.PolicyManagerUtil;
import javax.ws.rs.Consumes; import javax.ws.rs.*;
import javax.ws.rs.GET; import javax.ws.rs.core.MediaType;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Response; import javax.ws.rs.core.Response;
import java.util.ArrayList;
import java.util.List;
/** /**
* General Tenant Configuration REST-API implementation. * General Tenant Configuration REST-API implementation.
* All end points support JSON, XMl with content negotiation. * All end points support JSON, XMl with content negotiation.
*/ */
@Api(value = "Configuration", description = "General Tenant Configuration implementation")
@SuppressWarnings("NonJaxWsWebServices") @SuppressWarnings("NonJaxWsWebServices")
@Produces({"application/json", "application/xml"}) @Produces({ "application/json", "application/xml" })
@Consumes({ "application/json", "application/xml" }) @Consumes({ "application/json", "application/xml" })
public class Configuration { public interface Configuration {
private static Log log = LogFactory.getLog(Configuration.class);
@POST @POST
public Response saveTenantConfiguration(TenantConfiguration configuration) { @ApiOperation(
ResponsePayload responseMsg = new ResponsePayload(); consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
try { produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
DeviceMgtAPIUtils.getTenantConfigurationManagementService().saveConfiguration(configuration, httpMethod = "POST",
MDMAppConstants.RegistryConstants.GENERAL_CONFIG_RESOURCE_PATH); value = "Configuring general platform settings",
//Schedule the task service notes = "Configure the general platform settings using this REST API",
DeviceMgtAPIUtils.scheduleTaskService(DeviceMgtAPIUtils.getNotifierFrequency(configuration)); response = ResponsePayload.class)
responseMsg.setMessageFromServer("Tenant configuration saved successfully."); @ApiResponses(value = {
responseMsg.setStatusCode(HttpStatus.SC_CREATED); @ApiResponse(code = 200, message = "Tenant configuration saved successfully"),
return Response.status(Response.Status.CREATED).entity(responseMsg).build(); @ApiResponse(code = 500, message = "Error occurred while saving the tenant configuration")
} catch (ConfigurationManagementException e) { })
String msg = "Error occurred while saving the tenant configuration."; Response saveTenantConfiguration(@ApiParam(name = "configuration", value = "The required properties to "
log.error(msg, e); + "update the platform configurations the as the <JSON_PAYLOAD> value",
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); required = true) TenantConfiguration configuration);
}
}
@GET @GET
public Response getConfiguration() { @ApiOperation(
String msg; consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
try { produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
TenantConfiguration tenantConfiguration = DeviceMgtAPIUtils.getTenantConfigurationManagementService(). httpMethod = "GET",
getConfiguration(MDMAppConstants.RegistryConstants.GENERAL_CONFIG_RESOURCE_PATH); value = "Getting General Platform Configurations",
ConfigurationEntry configurationEntry = new ConfigurationEntry(); notes = "Get the general platform level configuration details using this REST API",
configurationEntry.setContentType("text"); response = TenantConfiguration.class)
configurationEntry.setName("notifierFrequency"); @ApiResponses(value = {
configurationEntry.setValue(PolicyManagerUtil.getMonitoringFequency()); @ApiResponse(code = 200, message = "OK"),
List<ConfigurationEntry> configList = tenantConfiguration.getConfiguration(); @ApiResponse(code = 500, message = "Error occurred while retrieving the tenant configuration")
if (configList == null) { })
configList = new ArrayList<>(); Response getConfiguration();
}
configList.add(configurationEntry);
tenantConfiguration.setConfiguration(configList);
return Response.status(Response.Status.OK).entity(tenantConfiguration).build();
} catch (ConfigurationManagementException e) {
msg = "Error occurred while retrieving the tenant configuration.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@PUT @PUT
public Response updateConfiguration(TenantConfiguration configuration) { @ApiOperation(
ResponsePayload responseMsg = new ResponsePayload(); consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
try { produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
DeviceMgtAPIUtils.getTenantConfigurationManagementService().saveConfiguration(configuration, httpMethod = "PUT",
MDMAppConstants.RegistryConstants.GENERAL_CONFIG_RESOURCE_PATH); value = "Updating General Platform Configurations",
//Schedule the task service notes = "Update the notification frequency using this REST API",
DeviceMgtAPIUtils.scheduleTaskService(DeviceMgtAPIUtils.getNotifierFrequency(configuration)); response = ResponsePayload.class)
responseMsg.setMessageFromServer("Tenant configuration updated successfully."); @ApiResponses(value = {
responseMsg.setStatusCode(HttpStatus.SC_CREATED); @ApiResponse(code = 200, message = "Tenant configuration updated successfully"),
return Response.status(Response.Status.CREATED).entity(responseMsg).build(); @ApiResponse(code = 500, message = "Error occurred while updating the tenant configuration")
} catch (ConfigurationManagementException e) { })
String msg = "Error occurred while updating the tenant configuration."; Response updateConfiguration(@ApiParam(name = "configuration", value = "The required properties to update"
log.error(msg, e); + " the platform configurations the as the <JSON_PAYLOAD> value",
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); required = true) TenantConfiguration configuration);
}
}
} }

@ -18,36 +18,20 @@
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.httpclient.HttpStatus; import io.swagger.annotations.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.core.service.DeviceManagementAdminService;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.EnrolmentInfo; import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
import org.wso2.carbon.device.mgt.common.PaginationRequest;
import org.wso2.carbon.device.mgt.core.dto.DeviceType; import org.wso2.carbon.device.mgt.core.dto.DeviceType;
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
import javax.ws.rs.DELETE; import javax.ws.rs.*;
import javax.ws.rs.GET;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
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.util.List;
/** /**
* Device related operations * Device related operations such as get all the available devices, etc.
*/ */
@Api(value = "Devices")
@SuppressWarnings("NonJaxWsWebServices") @SuppressWarnings("NonJaxWsWebServices")
public class Device { public interface Device {
private static Log log = LogFactory.getLog(Device.class);
/** /**
* Get all devices. We have to use accept all the necessary query parameters sent by datatable. * Get all devices. We have to use accept all the necessary query parameters sent by datatable.
@ -56,49 +40,41 @@ public class Device {
* @return Device List * @return Device List
*/ */
@GET @GET
public Response getAllDevices(@QueryParam("type") String type, @QueryParam("user") String user, @ApiOperation(
@QueryParam("role") String role, @QueryParam("status") EnrolmentInfo.Status status, consumes = MediaType.APPLICATION_JSON,
@QueryParam("start") int startIdx, @QueryParam("length") int length, produces = MediaType.APPLICATION_JSON,
@QueryParam("device-name") String deviceName, httpMethod = "GET",
@QueryParam("ownership") EnrolmentInfo.OwnerShip ownership) { value = "Returns device list",
try { notes = "Returns the set of devices that matches a given device type, user, role, "
DeviceManagementProviderService service = DeviceMgtAPIUtils.getDeviceManagementService(); + "enrollment status, ownership type",
//Length > 0 means this is a pagination request. response = org.wso2.carbon.device.mgt.common.Device.class,
if (length > 0) { responseContainer = "List")
PaginationRequest paginationRequest = new PaginationRequest(startIdx, length); @ApiResponses(value = {
paginationRequest.setDeviceName(deviceName); @ApiResponse(code = 200, message = "List of Devices"),
paginationRequest.setOwner(user); @ApiResponse(code = 500, message = "Error occurred while fetching the device list")
if (ownership != null) { })
paginationRequest.setOwnership(ownership.toString()); Response getAllDevices(@ApiParam(name = "type", value = "Provide the device type, such as ios, android or"
} + " windows", required = true) @QueryParam("type") String type,
if (status != null) { @ApiParam(name = "user", value = "Get the details of the devices registered to a "
paginationRequest.setStatus(status.toString()); + "user by providing the user name", required = true) @QueryParam("user")
} String user,
paginationRequest.setDeviceType(type); @ApiParam(name = "role", value = "Get the details of the devices registered to a "
return Response.status(Response.Status.OK).entity(service.getAllDevices(paginationRequest)).build(); + "specific role by providing the role name", required = true)
} @QueryParam("role") String role,
@ApiParam(name = "status", value = "Provide the device status details, such as "
List<org.wso2.carbon.device.mgt.common.Device> allDevices; + "active or inactive", required = true) @QueryParam("status")
if ((type != null) && !type.isEmpty()) { EnrolmentInfo.Status status,
allDevices = service.getAllDevices(type); @ApiParam(name = "start", value = "Provide the starting pagination index",
} else if ((user != null) && !user.isEmpty()) { required = true) @QueryParam("start") int startIdx,
allDevices = service.getDevicesOfUser(user); @ApiParam(name = "length", value = "Provide how many device details you require "
} else if ((role != null) && !role.isEmpty()) { + "from the starting pagination index", required = true)
allDevices = service.getAllDevicesOfRole(role); @QueryParam("length") int length,
} else if (status != null) { @ApiParam(name = "device-name", value = "Provide the name of a registered device "
allDevices = service.getDevicesByStatus(status); + "and receive the specified device details", required = true)
} else if (deviceName != null) { @QueryParam("device-name") String deviceName,
allDevices = service.getDevicesByName(deviceName); @ApiParam(name = "ownership", value = "Provide the device ownership type and "
} else { + "receive the specific device details", required = true)
allDevices = service.getAllDevices(); @QueryParam("ownership") EnrolmentInfo.OwnerShip ownership);
}
return Response.status(Response.Status.OK).entity(allDevices).build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the device list.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/** /**
* Fetch device details for a given device type and device Id. * Fetch device details for a given device type and device Id.
@ -107,32 +83,8 @@ public class Device {
*/ */
@GET @GET
@Path("view") @Path("view")
@Produces({MediaType.APPLICATION_JSON}) @Produces({ MediaType.APPLICATION_JSON })
public Response getDevice(@QueryParam("type") String type, Response getDevice(@QueryParam("type") String type, @QueryParam("id") String id);
@QueryParam("id") String id) {
DeviceIdentifier deviceIdentifier = DeviceMgtAPIUtils.instantiateDeviceIdentifier(type, id);
DeviceManagementProviderService deviceManagementProviderService = DeviceMgtAPIUtils.getDeviceManagementService();
org.wso2.carbon.device.mgt.common.Device device;
try {
device = deviceManagementProviderService.getDevice(deviceIdentifier);
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the device information.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
if (device == null) {
responsePayload.setStatusCode(HttpStatus.SC_NOT_FOUND);
responsePayload.setMessageFromServer("Requested device by type: " +
type + " and id: " + id + " does not exist.");
return Response.status(Response.Status.NOT_FOUND).entity(responsePayload).build();
} else {
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Sending Requested device by type: " + type + " and id: " + id + ".");
responsePayload.setResponseContent(device);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
}
/** /**
* Fetch device details of a given user. * Fetch device details of a given user.
@ -142,20 +94,7 @@ public class Device {
*/ */
@GET @GET
@Path("user/{user}") @Path("user/{user}")
public Response getDevice(@PathParam("user") String user) { Response getDevice(@PathParam("user") String user);
List<org.wso2.carbon.device.mgt.common.Device> devices;
try {
devices = DeviceMgtAPIUtils.getDeviceManagementService().getDevicesOfUser(user);
if (devices == null) {
return Response.status(Response.Status.NOT_FOUND).build();
}
return Response.status(Response.Status.OK).entity(devices).build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the devices list of given user.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/** /**
* Fetch device count of a given user. * Fetch device count of a given user.
@ -165,16 +104,7 @@ public class Device {
*/ */
@GET @GET
@Path("user/{user}/count") @Path("user/{user}/count")
public Response getDeviceCount(@PathParam("user") String user) { Response getDeviceCount(@PathParam("user") String user);
try {
Integer count = DeviceMgtAPIUtils.getDeviceManagementService().getDeviceCount(user);
return Response.status(Response.Status.OK).entity(count).build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the devices list of given user.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/** /**
* Get current device count * Get current device count
@ -183,16 +113,16 @@ public class Device {
*/ */
@GET @GET
@Path("count") @Path("count")
public Response getDeviceCount() { @ApiOperation(
try { httpMethod = "GET",
Integer count = DeviceMgtAPIUtils.getDeviceManagementService().getDeviceCount(); value = "Getting the Device Count",
return Response.status(Response.Status.OK).entity(count).build(); notes = "Get the number of devices that are registered with WSO2 EMM.",
} catch (DeviceManagementException e) { response = Integer.class)
String msg = "Error occurred while fetching the device count."; @ApiResponses(value = {
log.error(msg, e); @ApiResponse(code = 200, message = "Device count"),
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); @ApiResponse(code = 500, message = "Error occurred while fetching the device count")
} })
} Response getDeviceCount();
/** /**
* Get the list of devices that matches with the given name. * Get the list of devices that matches with the given name.
@ -203,37 +133,40 @@ public class Device {
*/ */
@GET @GET
@Path("name/{name}/{tenantDomain}") @Path("name/{name}/{tenantDomain}")
public Response getDevicesByName(@PathParam("name") String deviceName, @ApiOperation(
@PathParam("tenantDomain") String tenantDomain) { httpMethod = "GET",
List<org.wso2.carbon.device.mgt.common.Device> devices; value = "Get the device details of a specific device via the REST API",
try { notes = "Get the device details of a specific device",
devices = DeviceMgtAPIUtils.getDeviceManagementService().getDevicesByName(deviceName); response = DeviceType.class,
return Response.status(Response.Status.OK).entity(devices).build(); responseContainer = "List")
} catch (DeviceManagementException e) { @ApiResponses(value = {
String msg = "Error occurred while fetching the devices list of device name."; @ApiResponse(code = 200, message = "List of devices"),
log.error(msg, e); @ApiResponse(code = 500, message = "Error occurred while fetching the devices list of device name")
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); })
} Response getDevicesByName(@ApiParam(name = "name", value = "The name of the device or windows",
} required = true) @PathParam("name") String deviceName,
@ApiParam(name = "tenantDomain", value = "Tenant domain name. The default "
+ "tenant domain of WSO2 EMM is carbon.super", required = true)
@PathParam("tenantDomain") String tenantDomain);
/** /**
* Get the list of available device types. * Get the list of available device types.
* *
* @return list of device types. * @return list of device types.
*/ */
@GET @GET
@Path("types") @Path("types")
public Response getDeviceTypes() { @ApiOperation(
List<DeviceType> deviceTypes; httpMethod = "GET",
try { value = "Getting Details of the Devices Supported via WSO2 EMM",
deviceTypes = DeviceMgtAPIUtils.getDeviceManagementService().getAvailableDeviceTypes(); notes = "You are able to register Android, iOS and Windows devices with WSO2 EMM. This API will "
return Response.status(Response.Status.OK).entity(deviceTypes).build(); + "retrieve the device type details that can register with the EMM",
} catch (DeviceManagementException e) { response = DeviceType.class,
String msg = "Error occurred while fetching the list of device types."; responseContainer = "List")
log.error(msg, e); @ApiResponses(value = {
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); @ApiResponse(code = 200, message = "List of devices based on the type"),
} @ApiResponse(code = 500, message = "Error occurred while fetching the list of device types") })
} Response getDeviceTypes();
/** /**
* Update device. * Update device.
@ -242,24 +175,8 @@ public class Device {
*/ */
@PUT @PUT
@Path("type/{type}/id/{deviceId}") @Path("type/{type}/id/{deviceId}")
public Response updateDevice(@PathParam("type") String deviceType, @PathParam("deviceId") String deviceId, Response updateDevice(@PathParam("type") String deviceType, @PathParam("deviceId") String deviceId,
org.wso2.carbon.device.mgt.common.Device updatedDevice) { org.wso2.carbon.device.mgt.common.Device updatedDevice);
try {
DeviceManagementProviderService deviceManagementService = DeviceMgtAPIUtils.getDeviceManagementService();
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
deviceIdentifier.setType(deviceType);
deviceIdentifier.setId(deviceId);
org.wso2.carbon.device.mgt.common.Device device = deviceManagementService.getDevice(deviceIdentifier);
device.setName(updatedDevice.getName());
device.setDescription(updatedDevice.getDescription());
Boolean response = deviceManagementService.modifyEnrollment(device);
return Response.status(Response.Status.OK).entity(response).build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the list of device types.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/** /**
* disenroll device. * disenroll device.
@ -268,18 +185,6 @@ public class Device {
*/ */
@DELETE @DELETE
@Path("type/{type}/id/{deviceId}") @Path("type/{type}/id/{deviceId}")
public Response disenrollDevice(@PathParam("type") String deviceType, @PathParam("deviceId") String deviceId) { Response disenrollDevice(@PathParam("type") String deviceType, @PathParam("deviceId") String deviceId);
try {
DeviceManagementProviderService deviceManagementService = DeviceMgtAPIUtils.getDeviceManagementService();
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
deviceIdentifier.setType(deviceType);
deviceIdentifier.setId(deviceId);
Boolean response = deviceManagementService.disenrollDevice(deviceIdentifier);
return Response.status(Response.Status.OK).entity(response).build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the list of device types.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
} }

@ -16,65 +16,67 @@
* under the License. * under the License.
*/ */
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.logging.Log; import io.swagger.annotations.Api;
import org.apache.commons.logging.LogFactory; import io.swagger.annotations.ApiOperation;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier; import io.swagger.annotations.ApiParam;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import org.wso2.carbon.device.mgt.common.device.details.DeviceInfo; import org.wso2.carbon.device.mgt.common.device.details.DeviceInfo;
import org.wso2.carbon.device.mgt.common.device.details.DeviceLocation; import org.wso2.carbon.device.mgt.common.device.details.DeviceLocation;
import org.wso2.carbon.device.mgt.core.device.details.mgt.DeviceDetailsMgtException; import org.wso2.carbon.device.mgt.jaxrs.beans.UserCredentialWrapper;
import org.wso2.carbon.device.mgt.core.device.details.mgt.DeviceInformationManager;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import javax.ws.rs.GET; import javax.ws.rs.GET;
import javax.ws.rs.Path; import javax.ws.rs.Path;
import javax.ws.rs.PathParam; import javax.ws.rs.PathParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response; import javax.ws.rs.core.Response;
/**
* Device information related operations.
*/
@Api(value = "DeviceInfo")
@SuppressWarnings("NonJaxWsWebServices") @SuppressWarnings("NonJaxWsWebServices")
public class DeviceInformation { public interface DeviceInformation {
private static Log log = LogFactory.getLog(DeviceInformation.class);
@GET @GET
@Path("{type}/{id}") @Path("{type}/{id}")
public Response getDeviceInfo(@PathParam("type") String type, @PathParam("id") String id) { @ApiOperation(
DeviceInformationManager informationManager; produces = MediaType.APPLICATION_JSON,
DeviceInfo deviceInfo; httpMethod = "GET",
try { value = "Get device information",
DeviceIdentifier deviceIdentifier = new DeviceIdentifier(); notes = "This will return device information such as CPU usage, memory usage etc.",
deviceIdentifier.setId(id); response = DeviceInfo.class)
deviceIdentifier.setType(type); @ApiResponses(value = {
informationManager = DeviceMgtAPIUtils.getDeviceInformationManagerService(); @ApiResponse(code = 200, message = ""),
deviceInfo = informationManager.getDeviceInfo(deviceIdentifier); @ApiResponse(code = 400, message = ""),
} catch (DeviceDetailsMgtException e) { @ApiResponse(code = 400, message = ""),
String msg = "Error occurred while getting the device information."; @ApiResponse(code = 500, message = "Internal Server Error")
log.error(msg, e); })
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); Response getDeviceInfo(@ApiParam(name = "type", value = "Provide the device type, such as ios, android "
} + "or windows", required = true) @PathParam("type") String type,
return Response.status(Response.Status.OK).entity(deviceInfo).build(); @ApiParam(name = "id", value = "Provide the device identifier", required = true)
} @PathParam("id") String id);
@GET @GET
@Path("location/{type}/{id}") @Path("location/{type}/{id}")
public Response getDeviceLocation(@PathParam("type") String type, @PathParam("id") String id) { @ApiOperation(
DeviceInformationManager informationManager; produces = MediaType.APPLICATION_JSON,
DeviceLocation deviceLocation; httpMethod = "GET",
try { value = "Get the device location",
DeviceIdentifier deviceIdentifier = new DeviceIdentifier(); notes = "This will return the device location including latitude and longitude as well the "
deviceIdentifier.setId(id); + "physical address",
deviceIdentifier.setType(type); response = DeviceLocation.class)
informationManager = DeviceMgtAPIUtils.getDeviceInformationManagerService(); @ApiResponses(value = {
deviceLocation = informationManager.getDeviceLocation(deviceIdentifier); @ApiResponse(code = 200, message = ""),
} catch (DeviceDetailsMgtException e) { @ApiResponse(code = 400, message = ""),
String msg = "Error occurred while getting the device location."; @ApiResponse(code = 400, message = ""),
log.error(msg, e); @ApiResponse(code = 500, message = "Internal Server Error")
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); })
} Response getDeviceLocation(@ApiParam(name = "type", value = "Provide the device type, such as ios, "
return Response.status(Response.Status.OK).entity(deviceLocation).build(); + "android or windows", required = true) @PathParam("type") String type,
} @ApiParam(name = "id", value = "Provide the device identifier",
} required = true) @PathParam("id") String id);
}

@ -18,12 +18,12 @@
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.httpclient.HttpStatus; import io.swagger.annotations.Api;
import org.apache.commons.logging.Log; import io.swagger.annotations.ApiOperation;
import org.apache.commons.logging.LogFactory; import io.swagger.annotations.ApiParam;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils; import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import org.wso2.carbon.device.mgt.common.notification.mgt.Notification; import org.wso2.carbon.device.mgt.common.notification.mgt.Notification;
import org.wso2.carbon.device.mgt.common.notification.mgt.NotificationManagementException;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload; import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import javax.ws.rs.Consumes; import javax.ws.rs.Consumes;
@ -33,77 +33,86 @@ import javax.ws.rs.PUT;
import javax.ws.rs.Path; import javax.ws.rs.Path;
import javax.ws.rs.PathParam; import javax.ws.rs.PathParam;
import javax.ws.rs.Produces; import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response; import javax.ws.rs.core.Response;
import java.util.List;
/** /**
* DeviceNotification management REST-API implementation. * DeviceNotification management REST-API implementation.
* All end points support JSON, XMl with content negotiation. * All end points support JSON, XMl with content negotiation.
*/ */
@Api(value = "DeviceNotification")
@SuppressWarnings("NonJaxWsWebServices") @SuppressWarnings("NonJaxWsWebServices")
@Produces({"application/json", "application/xml"}) @Produces({"application/json", "application/xml"})
@Consumes({ "application/json", "application/xml" }) @Consumes({ "application/json", "application/xml" })
public class DeviceNotification { public interface DeviceNotification {
private static Log log = LogFactory.getLog(Configuration.class); @GET
@ApiOperation(
consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
httpMethod = "GET",
value = "Getting all Device Notification Details",
notes = "Get the details of all notifications that were pushed to the device in WSO2 EMM using "
+ "this REST API",
response = Notification.class,
responseContainer = "List")
@ApiResponses(value = {
@ApiResponse(code = 200, message = "List of Notifications"),
@ApiResponse(code = 500, message = "Error occurred while retrieving the notification list")
})
Response getNotifications();
@GET @GET
public Response getNotifications() { @Path("{status}")
String msg; @ApiOperation(
try { consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
List<Notification> notifications = DeviceMgtAPIUtils.getNotificationManagementService().getAllNotifications(); produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
return Response.status(Response.Status.OK).entity(notifications).build(); httpMethod = "GET",
} catch (NotificationManagementException e) { value = "Getting the Device Notifications Filtered by the Status",
msg = "Error occurred while retrieving the notification list."; notes = "Get the details of all the unread notifications or the details of all the read "
log.error(msg, e); + "notifications using this REST API",
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); response = Notification.class,
} responseContainer = "List")
} @ApiResponses(value = {
@ApiResponse(code = 200, message = "List of Notifications"),
@ApiResponse(code = 500, message = "Error occurred while retrieving the notification list")
})
Response getNotificationsByStatus(@ApiParam(name = "status", value = "Provide the notification status as"
+ " the value for {status}", required = true)
@PathParam("status") Notification.Status status);
@GET @PUT
@Path("{status}") @Path("{id}/{status}")
public Response getNotificationsByStatus(@PathParam("status") Notification.Status status) { @ApiOperation(
String msg; consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
try { produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
List<Notification> notifications = DeviceMgtAPIUtils.getNotificationManagementService().getNotificationsByStatus(status); httpMethod = "PUT",
return Response.status(Response.Status.OK).entity(notifications).build(); value = "Updating the Device Notification Status",
} catch (NotificationManagementException e) { notes = "When a user has read the the device notification the device notification status must "
msg = "Error occurred while retrieving the notification list."; + "change from NEW to CHECKED. Update the device notification status using this REST API",
log.error(msg, e); response = ResponsePayload.class)
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); @ApiResponses(value = {
} @ApiResponse(code = 200, message = "Notification status updated successfully"),
} @ApiResponse(code = 500, message = "Error occurred while updating notification status")
})
Response updateNotificationStatus( @ApiParam(name = "id", value = "Provide the ID of the notification"
+ " you wish you update", required = true) @PathParam("id") int id,
@ApiParam(name = "status", value = "Provide the notification status as"
+ " the value", required = true) @PathParam("status")
Notification.Status status);
@PUT @POST
@Path("{id}/{status}") @ApiOperation(
public Response updateNotificationStatus(@PathParam("id") int id, consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
@PathParam("status") Notification.Status status) { produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
ResponsePayload responseMsg = new ResponsePayload(); httpMethod = "POST",
try { value = "Sending a Device Notification",
DeviceMgtAPIUtils.getNotificationManagementService().updateNotificationStatus(id, status); notes = "Notify users on device operation failures and other information using this REST API",
responseMsg.setMessageFromServer("Notification status updated successfully."); response = ResponsePayload.class)
responseMsg.setStatusCode(HttpStatus.SC_ACCEPTED); @ApiResponses(value = {
return Response.status(Response.Status.ACCEPTED).entity(responseMsg).build(); @ApiResponse(code = 200, message = "NNotification has added successfully"),
} catch (NotificationManagementException e) { @ApiResponse(code = 500, message = "Error occurred while updating notification status")
String msg = "Error occurred while updating notification status."; })
log.error(msg, e); Response addNotification(Notification notification);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@POST
public Response addNotification(Notification notification) {
ResponsePayload responseMsg = new ResponsePayload();
try {
DeviceMgtAPIUtils.getNotificationManagementService().addNotification(notification);
responseMsg.setMessageFromServer("Notification has added successfully.");
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (NotificationManagementException e) {
String msg = "Error occurred while updating notification status.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
} }

@ -16,40 +16,40 @@
* under the License. * under the License.
*/ */
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.logging.Log; import io.swagger.annotations.Api;
import org.apache.commons.logging.LogFactory; import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import org.wso2.carbon.device.mgt.common.PaginationResult;
import org.wso2.carbon.device.mgt.common.device.details.DeviceWrapper; import org.wso2.carbon.device.mgt.common.device.details.DeviceWrapper;
import org.wso2.carbon.device.mgt.common.search.SearchContext; import org.wso2.carbon.device.mgt.common.search.SearchContext;
import org.wso2.carbon.device.mgt.core.search.mgt.SearchManagerService;
import org.wso2.carbon.device.mgt.core.search.mgt.SearchMgtException;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import javax.ws.rs.GET; import javax.ws.rs.GET;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response; import javax.ws.rs.core.Response;
import java.util.List;
/**
* Device search related operations such as getting device information.
*/
@Api(value = "DeviceSearch")
@SuppressWarnings("NonJaxWsWebServices") @SuppressWarnings("NonJaxWsWebServices")
public class DeviceSearch { public interface DeviceSearch {
private static Log log = LogFactory.getLog(DeviceSearch.class);
@GET @GET
public Response getDeviceInfo(SearchContext searchContext) { @ApiOperation(
SearchManagerService searchManagerService; consumes = MediaType.APPLICATION_JSON,
List<DeviceWrapper> devices; httpMethod = "GET",
try { value = "Advanced Search for Devices via the Console",
searchManagerService = DeviceMgtAPIUtils.getSearchManagerService(); notes = "Carry out an advanced search via the EMM console",
devices = searchManagerService.search(searchContext); response = DeviceWrapper.class,
responseContainer = "List")
} catch (SearchMgtException e) { @ApiResponses(value = {
String msg = "Error occurred while searching the device information."; @ApiResponse(code = 200, message = "OK"),
log.error(msg, e); @ApiResponse(code = 500, message = "Error occurred while searching the device information")
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); })
} Response getDeviceInfo(@ApiParam(name = "enrollmentCertificates", value = "List of search conditions",
return Response.status(Response.Status.OK).entity(devices).build(); required = true) SearchContext searchContext);
}
} }

@ -18,28 +18,24 @@
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.logging.Log; import io.swagger.annotations.*;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
import javax.ws.rs.Consumes; import javax.ws.rs.Consumes;
import javax.ws.rs.GET; import javax.ws.rs.GET;
import javax.ws.rs.Path; import javax.ws.rs.Path;
import javax.ws.rs.PathParam; import javax.ws.rs.PathParam;
import javax.ws.rs.Produces; import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response; import javax.ws.rs.core.Response;
import java.util.List;
/** /**
* Features * Features
*/ */
@Api(value = "Feature")
@SuppressWarnings("NonJaxWsWebServices") @SuppressWarnings("NonJaxWsWebServices")
@Produces({"application/json", "application/xml"}) @Produces({"application/json", "application/xml"})
@Consumes({"application/json", "application/xml"}) @Consumes({"application/json", "application/xml"})
public class Feature { public interface Feature {
private static Log log = LogFactory.getLog(Feature.class);
/** /**
* Get all features for Mobile Device Type * Get all features for Mobile Device Type
@ -48,18 +44,20 @@ public class Feature {
*/ */
@GET @GET
@Path("/{type}") @Path("/{type}")
public Response getFeatures(@PathParam("type") String type) { @ApiOperation(
List<org.wso2.carbon.device.mgt.common.Feature> features; consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
DeviceManagementProviderService dmService; produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
try { httpMethod = "GET",
dmService = DeviceMgtAPIUtils.getDeviceManagementService(); value = "Get Feature Details of a Device",
features = dmService.getFeatureManager(type).getFeatures(); notes = "WSO2 EMM features enable you to carry out many operations on a given device platform. " +
} catch (DeviceManagementException e) { "Using this REST API you can get the features that can be carried out on a preferred device type," +
String msg = "Error occurred while retrieving the list of features"; " such as iOS, Android or Windows.",
log.error(msg, e); response = org.wso2.carbon.device.mgt.common.Feature.class,
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); responseContainer = "List")
} @ApiResponses(value = { @ApiResponse(code = 200, message = "List of Features"),
return Response.status(Response.Status.OK).entity(features).build(); @ApiResponse(code = 500, message = "Error occurred while retrieving the list of features" +
} ".") })
Response getFeatures(@ApiParam(name = "type", value = "Provide the device type, such as ios, android or windows",
required = true) @PathParam("type") String type);
} }

@ -18,19 +18,9 @@
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.logging.Log; import io.swagger.annotations.Api;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier; import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.PaginationResult;
import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroup; import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroup;
import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroupConstants;
import org.wso2.carbon.device.mgt.common.group.mgt.GroupAlreadyEixistException;
import org.wso2.carbon.device.mgt.common.group.mgt.GroupManagementException;
import org.wso2.carbon.device.mgt.common.group.mgt.GroupUser;
import org.wso2.carbon.device.mgt.core.service.GroupManagementProviderService;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.user.core.multiplecredentials.UserDoesNotExistException;
import javax.ws.rs.Consumes; import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE; import javax.ws.rs.DELETE;
@ -43,473 +33,144 @@ import javax.ws.rs.PathParam;
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.Response; import javax.ws.rs.core.Response;
import java.util.Arrays;
import java.util.Date;
import java.util.List; import java.util.List;
/**
*
*/
@Api(value = "Group")
@SuppressWarnings("NonJaxWsWebServices") @SuppressWarnings("NonJaxWsWebServices")
public class Group { public interface Group {
private static Log log = LogFactory.getLog(Group.class);
@POST @POST
@Consumes("application/json") @Consumes("application/json")
public Response createGroup(DeviceGroup group) { Response createGroup(DeviceGroup group);
String owner = PrivilegedCarbonContext.getThreadLocalCarbonContext().getUsername();
if (group == null) {
return Response.status(Response.Status.BAD_REQUEST).build();
}
group.setOwner(owner);
group.setDateOfCreation(new Date().getTime());
group.setDateOfLastUpdate(new Date().getTime());
try {
GroupManagementProviderService groupManagementService = DeviceMgtAPIUtils.getGroupManagementProviderService();
groupManagementService.createGroup(group, DeviceGroupConstants.Roles.DEFAULT_ADMIN_ROLE, DeviceGroupConstants.Permissions.DEFAULT_ADMIN_PERMISSIONS);
groupManagementService.addGroupSharingRole(owner, group.getName(), owner,
DeviceGroupConstants.Roles.DEFAULT_OPERATOR_ROLE,
DeviceGroupConstants.Permissions.DEFAULT_OPERATOR_PERMISSIONS);
groupManagementService.addGroupSharingRole(owner, group.getName(), owner, DeviceGroupConstants.Roles.DEFAULT_STATS_MONITOR_ROLE,
DeviceGroupConstants.Permissions.DEFAULT_STATS_MONITOR_PERMISSIONS);
groupManagementService.addGroupSharingRole(owner, group.getName(), owner, DeviceGroupConstants.Roles.DEFAULT_VIEW_POLICIES,
DeviceGroupConstants.Permissions.DEFAULT_VIEW_POLICIES_PERMISSIONS);
groupManagementService.addGroupSharingRole(owner, group.getName(), owner, DeviceGroupConstants.Roles.DEFAULT_MANAGE_POLICIES,
DeviceGroupConstants.Permissions.DEFAULT_MANAGE_POLICIES_PERMISSIONS);
groupManagementService.addGroupSharingRole(owner, group.getName(), owner, DeviceGroupConstants.Roles.DEFAULT_VIEW_EVENTS,
DeviceGroupConstants.Permissions.DEFAULT_VIEW_EVENTS_PERMISSIONS);
return Response.status(Response.Status.CREATED).build();
} catch (GroupAlreadyEixistException e) {
return Response.status(Response.Status.CONFLICT).entity(e.getMessage()).build();
} catch (GroupManagementException e) {
log.error(e.getErrorMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Path("/owner/{owner}/name/{groupName}") @Path("/owner/{owner}/name/{groupName}")
@PUT @PUT
@Consumes("application/json") @Consumes("application/json")
@Produces("application/json") @Produces("application/json")
public Response updateGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner, Response updateGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
DeviceGroup deviceGroup) { DeviceGroup deviceGroup);
try {
DeviceMgtAPIUtils.getGroupManagementProviderService().updateGroup(deviceGroup, groupName, owner);
return Response.status(Response.Status.OK).build();
} catch (GroupManagementException e) {
log.error(e.getErrorMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Path("/owner/{owner}/name/{groupName}") @Path("/owner/{owner}/name/{groupName}")
@DELETE @DELETE
public Response deleteGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner) { Response deleteGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner);
try {
DeviceMgtAPIUtils.getGroupManagementProviderService().deleteGroup(groupName, owner);
return Response.status(Response.Status.OK).build();
} catch (GroupManagementException e) {
log.error(e.getMessage());
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@GET @GET
@Produces("application/json") @Produces("application/json")
public Response getGroups(@QueryParam("start") int startIndex, @PathParam("length") int length) { Response getGroups(@QueryParam("start") int startIndex, @PathParam("length") int length);
try {
PaginationResult paginationResult = DeviceMgtAPIUtils.getGroupManagementProviderService()
.getGroups(startIndex, length);
if (paginationResult.getRecordsTotal() > 0) {
return Response.status(Response.Status.OK).entity(paginationResult).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Path("/all") @Path("/all")
@GET @GET
@Produces("application/json") @Produces("application/json")
public Response getAllGroups() { Response getAllGroups();
try {
GroupManagementProviderService groupManagementProviderService = DeviceMgtAPIUtils
.getGroupManagementProviderService();
PaginationResult paginationResult = groupManagementProviderService
.getGroups(0, groupManagementProviderService.getGroupCount());
if (paginationResult.getRecordsTotal() > 0) {
return Response.status(Response.Status.OK).entity(paginationResult.getData()).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Path("/user/{user}") @Path("/user/{user}")
@GET @GET
@Produces("application/json") @Produces("application/json")
public Response getGroups(@PathParam("user") String userName, @QueryParam("start") int startIndex, Response getGroups(@PathParam("user") String userName, @QueryParam("start") int startIndex,
@QueryParam("length") int length) { @QueryParam("length") int length);
try {
PaginationResult paginationResult = DeviceMgtAPIUtils.getGroupManagementProviderService()
.getGroups(userName, startIndex, length);
if (paginationResult.getRecordsTotal() > 0) {
return Response.status(Response.Status.OK).entity(paginationResult).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Path("/user/{user}/all") @Path("/user/{user}/all")
@GET @GET
@Produces("application/json") @Produces("application/json")
public Response getGroups(@PathParam("user") String userName) { Response getGroups(@PathParam("user") String userName);
try {
List<DeviceGroup> deviceGroups = DeviceMgtAPIUtils.getGroupManagementProviderService()
.getGroups(userName);
if (deviceGroups.size() > 0) {
return Response.status(Response.Status.OK).entity(deviceGroups).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Path("/owner/{owner}/name/{groupName}") @Path("/owner/{owner}/name/{groupName}")
@GET @GET
@Produces("application/json") @Produces("application/json")
public Response getGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner) { Response getGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner);
try {
DeviceGroup deviceGroup = DeviceMgtAPIUtils.getGroupManagementProviderService().getGroup(groupName, owner);
if (deviceGroup != null) {
return Response.status(Response.Status.OK).entity(deviceGroup).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Path("/user/{user}/search") @Path("/user/{user}/search")
@GET @GET
@Produces("application/json") @Produces("application/json")
public Response findGroups(@QueryParam("groupName") String groupName, Response findGroups(@QueryParam("groupName") String groupName, @PathParam("user") String user);
@PathParam("user") String user) {
try {
List<DeviceGroup> groups = DeviceMgtAPIUtils.getGroupManagementProviderService()
.findInGroups(groupName, user);
DeviceGroup[] deviceGroups = new DeviceGroup[groups.size()];
groups.toArray(deviceGroups);
return Response.status(Response.Status.OK).entity(deviceGroups).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Path("/user/{user}/all") @Path("/user/{user}/all")
@GET @GET
@Produces("application/json") @Produces("application/json")
public Response getGroups(@PathParam("user") String userName, Response getGroups(@PathParam("user") String userName, @QueryParam("permission") String permission);
@QueryParam("permission") String permission) {
try {
GroupManagementProviderService groupManagementService = DeviceMgtAPIUtils.getGroupManagementProviderService();
List<DeviceGroup> groups;
if (permission != null) {
groups = groupManagementService.getGroups(userName, permission);
} else {
groups = groupManagementService.getGroups(userName);
}
DeviceGroup[] deviceGroups = new DeviceGroup[groups.size()];
groups.toArray(deviceGroups);
return Response.status(Response.Status.OK).entity(deviceGroups).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Path("/count") @Path("/count")
@GET @GET
@Produces("application/json") @Produces("application/json")
public Response getAllGroupCount() { Response getAllGroupCount();
try {
int count = DeviceMgtAPIUtils.getGroupManagementProviderService().getGroupCount();
return Response.status(Response.Status.OK).entity(count).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Path("/user/{user}/count") @Path("/user/{user}/count")
@GET @GET
@Produces("application/json") @Produces("application/json")
public Response getGroupCount(@PathParam("user") String userName) { Response getGroupCount(@PathParam("user") String userName);
try {
int count = DeviceMgtAPIUtils.getGroupManagementProviderService().getGroupCount(userName);
return Response.status(Response.Status.OK).entity(count).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Path("/owner/{owner}/name/{groupName}/share") @Path("/owner/{owner}/name/{groupName}/share")
@PUT @PUT
@Produces("application/json") @Produces("application/json")
public Response shareGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner, Response shareGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@FormParam("shareUser") String shareUser, @FormParam("shareUser") String shareUser, @FormParam("roleName") String sharingRole);
@FormParam("roleName") String sharingRole) {
try {
boolean isShared = DeviceMgtAPIUtils.getGroupManagementProviderService().shareGroup(
shareUser, groupName, owner, sharingRole);
if (isShared) {
return Response.status(Response.Status.OK).build();
} else {
return Response.status(Response.Status.NOT_FOUND).entity("Group not found").build();
}
} catch (UserDoesNotExistException e) {
return Response.status(Response.Status.NOT_FOUND).entity(e.getMessage()).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Path("/owner/{owner}/name/{groupName}/unshare") @Path("/owner/{owner}/name/{groupName}/unshare")
@PUT @PUT
@Produces("application/json") @Produces("application/json")
public Response unShareGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner, Response unShareGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@FormParam("unShareUser") String unShareUser, @FormParam("unShareUser") String unShareUser,
@FormParam("roleName") String sharingRole) { @FormParam("roleName") String sharingRole);
try {
boolean isUnShared = DeviceMgtAPIUtils.getGroupManagementProviderService().unshareGroup(
unShareUser, groupName, owner, sharingRole);
if (isUnShared) {
return Response.status(Response.Status.OK).build();
} else {
return Response.status(Response.Status.NOT_FOUND).entity("Group not found").build();
}
} catch (UserDoesNotExistException e) {
return Response.status(Response.Status.NOT_FOUND).entity(e.getMessage()).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Path("/owner/{owner}/name/{groupName}/share/roles/{roleName}/permissions") @Path("/owner/{owner}/name/{groupName}/share/roles/{roleName}/permissions")
@PUT @PUT
@Produces("application/json") @Produces("application/json")
public Response addSharing(@QueryParam("shareUser") String shareUser, @PathParam("groupName") String groupName, Response addSharing(@QueryParam("shareUser") String shareUser, @PathParam("groupName") String groupName,
@PathParam("owner") String owner, @PathParam("owner") String owner, @PathParam("roleName") String roleName,
@PathParam("roleName") String roleName, @FormParam("permissions") String[] permissions);
@FormParam("permissions") String[] permissions) {
try {
boolean isAdded = DeviceMgtAPIUtils.getGroupManagementProviderService().addGroupSharingRole(
shareUser, groupName, owner, roleName, permissions);
if (isAdded) {
return Response.status(Response.Status.OK).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@DELETE @DELETE
@Path("/owner/{owner}/name/{groupName}/share/roles/{roleName}/permissions") @Path("/owner/{owner}/name/{groupName}/share/roles/{roleName}/permissions")
@Produces("application/json") @Produces("application/json")
public Response removeSharing(@QueryParam("userName") String userName, @PathParam("groupName") String groupName, Response removeSharing(@QueryParam("userName") String userName, @PathParam("groupName") String groupName,
@PathParam("owner") String owner, @PathParam("owner") String owner, @PathParam("roleName") String roleName);
@PathParam("roleName") String roleName) {
try {
boolean isRemoved = DeviceMgtAPIUtils.getGroupManagementProviderService().removeGroupSharingRole(
groupName, owner, roleName);
if (isRemoved) {
return Response.status(Response.Status.OK).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@GET @GET
@Path("/owner/{owner}/name/{groupName}/share/roles") @Path("/owner/{owner}/name/{groupName}/share/roles")
@Produces("application/json") @Produces("application/json")
public Response getRoles(@PathParam("groupName") String groupName, Response getRoles(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@PathParam("owner") String owner, @QueryParam("userName") String userName) { @QueryParam("userName") String userName);
try {
List<String> roles;
if (userName != null && !userName.isEmpty()) {
roles = DeviceMgtAPIUtils.getGroupManagementProviderService().getRoles(userName, groupName, owner);
} else {
roles = DeviceMgtAPIUtils.getGroupManagementProviderService().getRoles(groupName, owner);
}
String[] rolesArray = new String[roles.size()];
roles.toArray(rolesArray);
return Response.status(Response.Status.OK).entity(rolesArray).build();
} catch (UserDoesNotExistException e) {
return Response.status(Response.Status.NOT_FOUND).entity(e.getMessage()).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@PUT @PUT
@Path("/owner/{owner}/name/{groupName}/user/{userName}/share/roles") @Path("/owner/{owner}/name/{groupName}/user/{userName}/share/roles")
@Produces("application/json") @Produces("application/json")
public Response setRoles(@PathParam("groupName") String groupName, Response setRoles(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@PathParam("owner") String owner, @PathParam("userName") String userName, @PathParam("userName") String userName, List<String> selectedRoles);
List<String> selectedRoles) {
try {
List<String> allRoles = DeviceMgtAPIUtils.getGroupManagementProviderService().getRoles(groupName, owner);
for (String role : allRoles) {
if (selectedRoles.contains(role)) {
DeviceMgtAPIUtils.getGroupManagementProviderService()
.shareGroup(userName, groupName, owner, role);
} else {
DeviceMgtAPIUtils.getGroupManagementProviderService()
.unshareGroup(userName, groupName, owner, role);
}
}
return Response.status(Response.Status.OK).build();
} catch (UserDoesNotExistException e) {
return Response.status(Response.Status.NOT_FOUND).entity(e.getMessage()).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@GET @GET
@Path("/owner/{owner}/name/{groupName}/users") @Path("/owner/{owner}/name/{groupName}/users")
@Produces("application/json") @Produces("application/json")
public Response getUsers(@PathParam("groupName") String groupName, Response getUsers(@PathParam("groupName") String groupName, @PathParam("owner") String owner);
@PathParam("owner") String owner) {
try {
List<GroupUser> users = DeviceMgtAPIUtils.getGroupManagementProviderService().getUsers(
groupName, owner);
GroupUser[] usersArray = new GroupUser[users.size()];
users.toArray(usersArray);
return Response.status(Response.Status.OK).entity(usersArray).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@GET @GET
@Path("/owner/{owner}/name/{groupName}/devices") @Path("/owner/{owner}/name/{groupName}/devices")
@Produces("application/json") @Produces("application/json")
public Response getDevices(@PathParam("groupName") String groupName, @PathParam("owner") String owner, Response getDevices(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@QueryParam("start") int startIdx, @QueryParam("length") int length) { @QueryParam("start") int startIdx, @QueryParam("length") int length);
try {
PaginationResult paginationResult = DeviceMgtAPIUtils
.getGroupManagementProviderService().getDevices(groupName, owner, startIdx, length);
if (paginationResult.getRecordsTotal() > 0) {
return Response.status(Response.Status.OK).entity(paginationResult).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@GET @GET
@Path("/owner/{owner}/name/{groupName}/devices/count") @Path("/owner/{owner}/name/{groupName}/devices/count")
@Produces("application/json") @Produces("application/json")
public Response getDeviceCount(@PathParam("groupName") String groupName, Response getDeviceCount(@PathParam("groupName") String groupName, @PathParam("owner") String owner);
@PathParam("owner") String owner) {
try {
int count = DeviceMgtAPIUtils.getGroupManagementProviderService().getDeviceCount(groupName, owner);
return Response.status(Response.Status.OK).entity(count).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@POST @POST
@Path("/owner/{owner}/name/{groupName}/devices") @Path("/owner/{owner}/name/{groupName}/devices")
@Produces("application/json") @Produces("application/json")
public Response addDevice(@PathParam("groupName") String groupName, Response addDevice(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@PathParam("owner") String owner, DeviceIdentifier deviceIdentifier) { DeviceIdentifier deviceIdentifier);
try {
boolean isAdded = DeviceMgtAPIUtils.getGroupManagementProviderService().addDevice(
deviceIdentifier, groupName, owner);
if (isAdded) {
return Response.status(Response.Status.OK).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@DELETE @DELETE
@Path("/owner/{owner}/name/{groupName}/devices/{deviceType}/{deviceId}") @Path("/owner/{owner}/name/{groupName}/devices/{deviceType}/{deviceId}")
@Produces("application/json") @Produces("application/json")
public Response removeDevice(@PathParam("groupName") String groupName, Response removeDevice(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@PathParam("owner") String owner, @PathParam("deviceId") String deviceId, @PathParam("deviceId") String deviceId, @PathParam("deviceType") String deviceType);
@PathParam("deviceType") String deviceType) {
try {
DeviceIdentifier deviceIdentifier = new DeviceIdentifier(deviceId, deviceType);
boolean isRemoved = DeviceMgtAPIUtils.getGroupManagementProviderService().removeDevice(
deviceIdentifier, groupName, owner);
if (isRemoved) {
return Response.status(Response.Status.OK).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@GET @GET
@Path("/owner/{owner}/name/{groupName}/users/{userName}/permissions") @Path("/owner/{owner}/name/{groupName}/users/{userName}/permissions")
@Produces("application/json") @Produces("application/json")
public Response getPermissions(@PathParam("userName") String userName, Response getPermissions(@PathParam("userName") String userName, @PathParam("groupName") String groupName,
@PathParam("groupName") String groupName, @PathParam("owner") String owner);
@PathParam("owner") String owner) {
try {
String[] permissions = DeviceMgtAPIUtils.getGroupManagementProviderService()
.getPermissions(userName, groupName, owner);
return Response.status(Response.Status.OK).entity(permissions).build();
} catch (UserDoesNotExistException e) {
return Response.status(Response.Status.NOT_FOUND).entity(e.getMessage()).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
} }

@ -18,28 +18,18 @@
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.httpclient.HttpStatus; import io.swagger.annotations.Api;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import javax.ws.rs.GET; import javax.ws.rs.*;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType; import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response; import javax.ws.rs.core.Response;
/** /**
* This class represents license related operations. * This class represents license related operations.
*/ */
@Api(value = "License")
@SuppressWarnings("NonJaxWsWebServices") @SuppressWarnings("NonJaxWsWebServices")
public class License { public interface License {
private static Log log = LogFactory.getLog(License.class);
/** /**
* This method returns the license text related to a given device type and language code. * This method returns the license text related to a given device type and language code.
@ -49,29 +39,10 @@ public class License {
* @return Returns the license text * @return Returns the license text
*/ */
@GET @GET
@Path ("{deviceType}/{languageCode}") @Path("{deviceType}/{languageCode}")
@Produces ({MediaType.APPLICATION_JSON}) @Produces({ MediaType.APPLICATION_JSON })
public Response getLicense(@PathParam ("deviceType") String deviceType, Response getLicense(@PathParam("deviceType") String deviceType,
@PathParam("languageCode") String languageCode) { @PathParam("languageCode") String languageCode);
org.wso2.carbon.device.mgt.common.license.mgt.License license;
ResponsePayload responsePayload;
try {
license = DeviceMgtAPIUtils.getDeviceManagementService().getLicense(deviceType, languageCode);
if (license == null) {
return Response.status(HttpStatus.SC_NOT_FOUND).build();
}
responsePayload = ResponsePayload.statusCode(HttpStatus.SC_OK).
messageFromServer("License for '" + deviceType + "' was retrieved successfully").
responseContent(license.getText()).
build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while retrieving the license configured for '" + deviceType + "' device type";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/** /**
* This method is used to add license to a specific device type. * This method is used to add license to a specific device type.
@ -81,21 +52,7 @@ public class License {
* @return Returns the acknowledgement for the action * @return Returns the acknowledgement for the action
*/ */
@POST @POST
@Path ("{deviceType}") @Path("{deviceType}")
public Response addLicense(@PathParam ("deviceType") String deviceType, Response addLicense(@PathParam("deviceType") String deviceType,
org.wso2.carbon.device.mgt.common.license.mgt.License license) { org.wso2.carbon.device.mgt.common.license.mgt.License license);
ResponsePayload responsePayload;
try {
DeviceMgtAPIUtils.getDeviceManagementService().addLicense(deviceType, license);
responsePayload = ResponsePayload.statusCode(HttpStatus.SC_OK).
messageFromServer("License added successfully for '" + deviceType + "' device type").
build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while adding license for '" + deviceType + "' device type";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
} }

@ -18,203 +18,141 @@
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.httpclient.HttpStatus; import io.swagger.annotations.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException;
import org.wso2.carbon.device.mgt.jaxrs.api.context.DeviceOperationContext;
import org.wso2.carbon.device.mgt.jaxrs.api.util.MDMIOSOperationUtil;
import org.wso2.carbon.device.mgt.jaxrs.beans.ApplicationWrapper;
import org.wso2.carbon.device.mgt.jaxrs.beans.MobileApp;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.PaginationRequest;
import org.wso2.carbon.device.mgt.common.PaginationResult; import org.wso2.carbon.device.mgt.common.PaginationResult;
import org.wso2.carbon.device.mgt.common.Platform;
import org.wso2.carbon.device.mgt.common.app.mgt.Application; import org.wso2.carbon.device.mgt.common.app.mgt.Application;
import org.wso2.carbon.device.mgt.common.app.mgt.ApplicationManagementException; import org.wso2.carbon.device.mgt.jaxrs.api.context.DeviceOperationContext;
import org.wso2.carbon.device.mgt.common.app.mgt.ApplicationManager;
import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManagementException;
import org.wso2.carbon.device.mgt.core.app.mgt.ApplicationManagementProviderService;
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.api.util.MDMAndroidOperationUtil;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload; import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.device.mgt.jaxrs.beans.ApplicationWrapper;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET; import javax.ws.rs.GET;
import javax.ws.rs.POST; import javax.ws.rs.POST;
import javax.ws.rs.Path; import javax.ws.rs.Path;
import javax.ws.rs.PathParam; import javax.ws.rs.PathParam;
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.Response; import javax.ws.rs.core.Response;
import java.util.List;
/** /**
* Operation related REST-API implementation. *
*/ */
@SuppressWarnings("NonJaxWsWebServices") @Api(value = "Operation")
@Produces({"application/json", "application/xml"}) public interface Operation {
@Consumes({"application/json", "application/xml"})
public class Operation {
private static Log log = LogFactory.getLog(Operation.class);
/* @deprecated */ /* @deprecated */
@GET @GET
public Response getAllOperations() { Response getAllOperations();
List<? extends org.wso2.carbon.device.mgt.common.operation.mgt.Operation> operations;
DeviceManagementProviderService dmService;
try {
dmService = DeviceMgtAPIUtils.getDeviceManagementService();
operations = dmService.getOperations(null);
} catch (OperationManagementException e) {
String msg = "Error occurred while fetching the operations for the device.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).entity(operations).build();
}
@GET @GET
@Path("paginate/{type}/{id}") @Path("paginate/{type}/{id}")
public Response getDeviceOperations( @ApiOperation(
@PathParam("type") String type, @PathParam("id") String id, @QueryParam("start") int startIdx, consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
@QueryParam("length") int length, @QueryParam("search") String search) { produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
PaginationResult operations; httpMethod = "GET",
DeviceManagementProviderService dmService; value = "Getting Pagination Details for Operations on a Device.",
DeviceIdentifier deviceIdentifier = new DeviceIdentifier(); notes = "You will carry out many operations on a device. In a situation where you wish to view the all" +
PaginationRequest paginationRequest = new PaginationRequest(startIdx, length); " the operations carried out on a device it is not feasible to show all the details on one page" +
try { " therefore the details are paginated." +
deviceIdentifier.setType(type); " Example: You carry out 21 operations via a given device. When you wish to see the operations " +
deviceIdentifier.setId(id); "carried out, the details of the 21 operations will be broken down into 3 pages with 10 operation" +
dmService = DeviceMgtAPIUtils.getDeviceManagementService(); " details per page.",
operations = dmService.getOperations(deviceIdentifier, paginationRequest); response = org.wso2.carbon.device.mgt.common.operation.mgt.Operation.class)
} catch (OperationManagementException e) { @ApiResponses(value = { @ApiResponse(code = 200, message = "List of Operations on a device."),
String msg = "Error occurred while fetching the operations for the device."; @ApiResponse(code = 500, message = "Error occurred while fetching the operations for the " +
log.error(msg, e); "device.") })
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); Response getDeviceOperations(@ApiParam(name = "type", value = "Define the device type as the value for {type}. " +
} "Example: ios, android or windows.",
return Response.status(Response.Status.OK).entity(operations).build(); required = true) @PathParam("type") String type,
} @ApiParam(name = "id", value = "Define the device ID",
required = true) @PathParam("id") String id,
@ApiParam(name = "start", value = "Provide the starting pagination index. Example 10",
required = true) @QueryParam("start") int startIdx,
@ApiParam(name = "length", value = "Provide how many device details you require from" +
" the starting pagination index. For example if " +
"you require the device details from the 10th " +
"pagination index to the 15th, " +
"you must define 10 as the value for start and 5 " +
"as the value for length.",
required = true) @QueryParam("length") int length,
@QueryParam("search") String search);
@GET @GET
@Path("{type}/{id}") @Path("{type}/{id}")
public Response getDeviceOperations(@PathParam("type") String type, @PathParam("id") String id) { @ApiOperation(
List<? extends org.wso2.carbon.device.mgt.common.operation.mgt.Operation> operations; consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
DeviceManagementProviderService dmService; produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
DeviceIdentifier deviceIdentifier = new DeviceIdentifier(); httpMethod = "GET",
try { value = "Getting Device Operation Details.",
deviceIdentifier.setType(type); responseContainer = "List",
deviceIdentifier.setId(id); notes = "Get the details of operations carried out on a selected device.",
dmService = DeviceMgtAPIUtils.getDeviceManagementService(); response = org.wso2.carbon.device.mgt.common.operation.mgt.Operation.class)
operations = dmService.getOperations(deviceIdentifier); @ApiResponses(value = { @ApiResponse(code = 200, message = "List of Operations on a device."),
} catch (OperationManagementException e) { @ApiResponse(code = 500, message = "Error occurred while fetching the operations for the " +
String msg = "Error occurred while fetching the operations for the device."; "device.") })
log.error(msg, e); Response getDeviceOperations(@ApiParam(name = "type", value = "Define the device type as the value for {type}. " +
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); "Example: ios, android or windows.",
} required = true) @PathParam("type") String type,
return Response.status(Response.Status.OK).entity(operations).build(); @ApiParam(name = "id", value = "Define the device ID",
} required = true) @PathParam("id") String id);
/* @deprecated */ /* @deprecated */
@POST @POST
public Response addOperation(DeviceOperationContext operationContext) { Response addOperation(DeviceOperationContext operationContext);
DeviceManagementProviderService dmService;
ResponsePayload responseMsg = new ResponsePayload();
try {
dmService = DeviceMgtAPIUtils.getDeviceManagementService();
int operationId = dmService.addOperation(operationContext.getOperation(), operationContext.getDevices());
if (operationId > 0) {
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
responseMsg.setMessageFromServer("Operation has added successfully.");
}
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (OperationManagementException e) {
String msg = "Error occurred while saving the operation";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@GET @GET
@Path("{type}/{id}/apps") @Path("{type}/{id}/apps")
public Response getInstalledApps(@PathParam("type") String type, @PathParam("id") String id) { @ApiOperation(
List<Application> applications; consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
ApplicationManagementProviderService appManagerConnector; produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
DeviceIdentifier deviceIdentifier = new DeviceIdentifier(); httpMethod = "GET",
try { value = "Getting Installed Application Details of a Device.",
deviceIdentifier.setType(type); responseContainer = "List",
deviceIdentifier.setId(id); notes = "Get the list of applications that a device has subscribed.",
appManagerConnector = DeviceMgtAPIUtils.getAppManagementService(); response = Application.class)
applications = appManagerConnector.getApplicationListForDevice(deviceIdentifier); @ApiResponses(value = { @ApiResponse(code = 200, message = "List of installed application details of a device."),
} catch (ApplicationManagementException e) { @ApiResponse(code = 500, message = "Error occurred while fetching the apps of the device" +
String msg = "Error occurred while fetching the apps of the device."; ".") })
log.error(msg, e); Response getInstalledApps(@ApiParam(name = "type", value = "Define the device type as the value for {type}. " +
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); "Example: ios, android or windows.",
} required = true) @PathParam("type") String type,
return Response.status(Response.Status.CREATED).entity(applications).build(); @ApiParam(name = "id", value = "Define the device ID",
} required = true) @PathParam("id") String id);
@POST @POST
@Path("installApp/{tenantDomain}") @Path("installApp/{tenantDomain}")
public Response installApplication(ApplicationWrapper applicationWrapper, @ApiOperation(
@PathParam("tenantDomain") String tenantDomain) { consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
ResponsePayload responseMsg = new ResponsePayload(); produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
ApplicationManager appManagerConnector; httpMethod = "POST",
org.wso2.carbon.device.mgt.common.operation.mgt.Operation operation = null; value = "Installing an Application on a Device.",
try { notes = "Install a selected application on a device.")
appManagerConnector = DeviceMgtAPIUtils.getAppManagementService(); @ApiResponses(value = { @ApiResponse(code = 200, message = "Operation was successfully added to the queue."),
MobileApp mobileApp = applicationWrapper.getApplication(); @ApiResponse(code = 500, message = "Error occurred while saving the operation.") })
Response installApplication(@ApiParam(name = "applicationWrapper", value = "Details about the application and the" +
if (applicationWrapper.getDeviceIdentifiers() != null) { " users and roles it should be " +
for (DeviceIdentifier deviceIdentifier : applicationWrapper.getDeviceIdentifiers()) { "installed on.",
if (deviceIdentifier.getType().equals(Platform.android.toString())) { required = true) ApplicationWrapper applicationWrapper,
operation = MDMAndroidOperationUtil.createInstallAppOperation(mobileApp); @ApiParam(name = "tenantDomain", value = "Provide the tenant domain as the value for " +
} else if (deviceIdentifier.getType().equals(Platform.ios.toString())) { "{tenantDomain}. The default tenant domain " +
operation = MDMIOSOperationUtil.createInstallAppOperation(mobileApp); "of WSO2 EMM is carbon.super.",
} required = true) @PathParam("tenantDomain") String tenantDomain);
}
appManagerConnector.installApplicationForDevices(operation, applicationWrapper.getDeviceIdentifiers());
}
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
responseMsg.setMessageFromServer("Application installation request has been sent to the device.");
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (ApplicationManagementException | MDMAPIException e) {
String msg = "Error occurred while saving the operation";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@POST @POST
@Path("uninstallApp/{tenantDomain}") @Path("uninstallApp/{tenantDomain}")
public Response uninstallApplication(ApplicationWrapper applicationWrapper, @ApiOperation(
@PathParam("tenantDomain") String tenantDomain) { consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
ResponsePayload responseMsg = new ResponsePayload(); produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
ApplicationManager appManagerConnector; httpMethod = "POST",
org.wso2.carbon.device.mgt.common.operation.mgt.Operation operation = null; value = "Uninstalling an Application from a Device.",
try { notes = "Uninstall a selected application from a device.")
appManagerConnector = DeviceMgtAPIUtils.getAppManagementService(); @ApiResponses(value = { @ApiResponse(code = 200, message = "Operation was successfully added to the queue."),
MobileApp mobileApp = applicationWrapper.getApplication(); @ApiResponse(code = 500, message = "Error occurred while saving the operation.") })
Response uninstallApplication(@ApiParam(name = "applicationWrapper", value = "Details about the application and" +
if (applicationWrapper.getDeviceIdentifiers() != null) { " the users and roles it should be " +
for (DeviceIdentifier deviceIdentifier : applicationWrapper.getDeviceIdentifiers()) { "uninstalled.",
if (deviceIdentifier.getType().equals(Platform.android.toString())) { required = true) ApplicationWrapper applicationWrapper,
operation = MDMAndroidOperationUtil.createAppUninstallOperation(mobileApp); @ApiParam(name = "tenantDomain", value = "Provide the tenant domain as the value for " +
} else if (deviceIdentifier.getType().equals(Platform.ios.toString())) { "{tenantDomain}. The default tenant domain " +
operation = MDMIOSOperationUtil.createAppUninstallOperation(mobileApp); "of WSO2 EMM is carbon.super.",
} required = true) @PathParam("tenantDomain") String tenantDomain);
} }
appManagerConnector.installApplicationForDevices(operation, applicationWrapper.getDeviceIdentifiers());
}
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
responseMsg.setMessageFromServer("Application removal request has been sent to the device.");
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (ApplicationManagementException | MDMAPIException e) {
String msg = "Error occurred while saving the operation";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
}

@ -18,23 +18,11 @@
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.httpclient.HttpStatus; import io.swagger.annotations.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException; import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.beans.PriorityUpdatedPolicyWrapper;
import org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtUtil;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload; import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.device.mgt.jaxrs.beans.PolicyWrapper; import org.wso2.carbon.device.mgt.jaxrs.beans.PolicyWrapper;
import org.wso2.carbon.policy.mgt.common.PolicyAdministratorPoint; import org.wso2.carbon.device.mgt.jaxrs.beans.PriorityUpdatedPolicyWrapper;
import org.wso2.carbon.policy.mgt.common.PolicyManagementException;
import org.wso2.carbon.policy.mgt.common.PolicyMonitoringTaskException;
import org.wso2.carbon.policy.mgt.common.monitor.ComplianceData;
import org.wso2.carbon.policy.mgt.common.monitor.PolicyComplianceException;
import org.wso2.carbon.policy.mgt.core.PolicyManagerService;
import org.wso2.carbon.policy.mgt.core.task.TaskScheduleService;
import javax.ws.rs.Consumes; import javax.ws.rs.Consumes;
import javax.ws.rs.GET; import javax.ws.rs.GET;
@ -45,386 +33,233 @@ import javax.ws.rs.PathParam;
import javax.ws.rs.Produces; import javax.ws.rs.Produces;
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.util.ArrayList;
import java.util.List; import java.util.List;
@SuppressWarnings("NonJaxWsWebServices") /**
public class Policy { *
private static Log log = LogFactory.getLog(Policy.class); */
@Api(value = "Policy")
public interface Policy {
@POST @POST
@Path("inactive-policy") @Path("inactive-policy")
public Response addPolicy(PolicyWrapper policyWrapper) { @ApiOperation(
consumes = MediaType.APPLICATION_JSON,
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); produces = MediaType.APPLICATION_JSON,
ResponsePayload responseMsg = new ResponsePayload(); httpMethod = "POST",
org.wso2.carbon.policy.mgt.common.Policy policy = new org.wso2.carbon.policy.mgt.common.Policy(); value = "Adding a Policy.",
policy.setPolicyName(policyWrapper.getPolicyName()); notes = "Add a policy using this REST API command. When adding a policy you will have the option of " +
policy.setProfileId(policyWrapper.getProfileId()); "saving the policy or saving and publishing the policy. Using the REST API command given below " +
policy.setDescription(policyWrapper.getDescription()); "you are able to save a created Policy and this policy will be in the inactive state")
policy.setProfile(DeviceMgtUtil.convertProfile(policyWrapper.getProfile())); @ApiResponses(value = { @ApiResponse(code = 201, message = "Created the policy."),
policy.setOwnershipType(policyWrapper.getOwnershipType()); @ApiResponse(code = 500, message = "Policy Management related error occurred when " +
policy.setRoles(policyWrapper.getRoles()); "adding the policy") })
policy.setUsers(policyWrapper.getUsers()); Response addPolicy(@ApiParam(name = "policyWrapper", value = "Policy details related to the operation.",
policy.setTenantId(policyWrapper.getTenantId()); required = true) PolicyWrapper policyWrapper);
policy.setCompliance(policyWrapper.getCompliance());
return addPolicy(policyManagementService, responseMsg, policy);
}
@POST @POST
@Path("active-policy") @Path("active-policy")
public Response addActivePolicy(PolicyWrapper policyWrapper) { @ApiOperation(
consumes = MediaType.APPLICATION_JSON,
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); produces = MediaType.APPLICATION_JSON,
ResponsePayload responseMsg = new ResponsePayload(); httpMethod = "POST",
org.wso2.carbon.policy.mgt.common.Policy policy = new org.wso2.carbon.policy.mgt.common.Policy(); value = "Adding an Active Policy.",
policy.setPolicyName(policyWrapper.getPolicyName()); notes = "Add a policy that is in the active state using the REST API command. When adding a policy you " +
policy.setProfileId(policyWrapper.getProfileId()); "will have the option of saving the policy or saving and publishing the policy. Using the REST " +
policy.setDescription(policyWrapper.getDescription()); "API command given below you are able to save and publish a created policy and this policy will " +
policy.setProfile(DeviceMgtUtil.convertProfile(policyWrapper.getProfile())); "be in the active state.")
policy.setOwnershipType(policyWrapper.getOwnershipType()); @ApiResponses(value = { @ApiResponse(code = 201, message = "Created the policy."),
policy.setRoles(policyWrapper.getRoles()); @ApiResponse(code = 500, message = "Policy Management related error occurred when " +
policy.setUsers(policyWrapper.getUsers()); "adding the policy") })
policy.setTenantId(policyWrapper.getTenantId()); Response addActivePolicy(@ApiParam(name = "policyWrapper", value = "Policy details related to the operation.",
policy.setCompliance(policyWrapper.getCompliance()); required = true) PolicyWrapper policyWrapper);
policy.setActive(true);
return addPolicy(policyManagementService, responseMsg, policy);
}
private Response addPolicy(PolicyManagerService policyManagementService, ResponsePayload responseMsg,
org.wso2.carbon.policy.mgt.common.Policy policy) {
try {
PolicyAdministratorPoint pap = policyManagementService.getPAP();
pap.addPolicy(policy);
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
responseMsg.setMessageFromServer("Policy has been added successfully.");
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (PolicyManagementException e) {
String msg = "Policy Management related exception";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@GET @GET
@Produces({MediaType.APPLICATION_JSON}) @Produces({ MediaType.APPLICATION_JSON})
public Response getAllPolicies() { @ApiOperation(
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); consumes = MediaType.APPLICATION_JSON,
List<org.wso2.carbon.policy.mgt.common.Policy> policies; produces = MediaType.APPLICATION_JSON,
try { httpMethod = "GET",
PolicyAdministratorPoint policyAdministratorPoint = policyManagementService.getPAP(); value = "Getting Details of Policies.",
policies = policyAdministratorPoint.getPolicies(); responseContainer = "List",
} catch (PolicyManagementException e) { notes = "Retrieve the details of all the policies that you have created in WSO2 EMM.",
String msg = "Policy Management related exception"; response = org.wso2.carbon.policy.mgt.common.Policy.class)
log.error(msg, e); @ApiResponses(value = { @ApiResponse(code = 200, message = "Fetched all policies."),
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); @ApiResponse(code = 500, message = "Policy Management related error occurred when " +
} "fetching the policies.") })
ResponsePayload responsePayload = new ResponsePayload(); Response getAllPolicies();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Sending all retrieved device policies.");
responsePayload.setResponseContent(policies);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@GET @GET
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
@Path("{id}") @Path("{id}")
public Response getPolicy(@PathParam("id") int policyId) { @ApiOperation(
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); consumes = MediaType.APPLICATION_JSON,
final org.wso2.carbon.policy.mgt.common.Policy policy; produces = MediaType.APPLICATION_JSON,
try { httpMethod = "GET",
PolicyAdministratorPoint policyAdministratorPoint = policyManagementService.getPAP(); value = "Getting Details of a Policy.",
policy = policyAdministratorPoint.getPolicy(policyId); notes = "Retrieve the details of a selected policy in WSO2 EMM.")
} catch (PolicyManagementException e) { @ApiResponses(value = { @ApiResponse(code = 200, message = "Fetched policy details."),
String msg = "Policy Management related exception"; @ApiResponse(code = 500, message = "Policy Management related error occurred when " +
log.error(msg, e); "fetching the policies.") })
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); Response getPolicy(@ApiParam(name = "id", value = "Policy ID value to identify a policy uniquely.",
} required = true) @PathParam("id") int policyId);
if (policy == null){
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_NOT_FOUND);
responsePayload.setMessageFromServer("Policy for ID " + policyId + " not found.");
return Response.status(Response.Status.NOT_FOUND).entity(responsePayload).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Sending all retrieved device policies.");
responsePayload.setResponseContent(policy);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@GET @GET
@Path("count") @Path("count")
public Response getPolicyCount() { @ApiOperation(
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); consumes = MediaType.APPLICATION_JSON,
try { produces = MediaType.APPLICATION_JSON,
PolicyAdministratorPoint policyAdministratorPoint = policyManagementService.getPAP(); httpMethod = "GET",
Integer count = policyAdministratorPoint.getPolicyCount(); value = "Getting the Policy Count.",
return Response.status(Response.Status.OK).entity(count).build(); notes = "Get the number of policies that are created in WSO2 EMM.",
} catch (PolicyManagementException e) { response = Integer.class)
String msg = "Policy Management related exception"; @ApiResponses(value = { @ApiResponse(code = 200, message = "Fetched the policy count."),
log.error(msg, e); @ApiResponse(code = 500, message = "Error while Fetching the policy count.") })
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); Response getPolicyCount();
}
}
@PUT @PUT
@Path("{id}") @Path("{id}")
public Response updatePolicy(PolicyWrapper policyWrapper, @PathParam("id") int policyId) { @ApiOperation(
consumes = MediaType.APPLICATION_JSON,
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); produces = MediaType.APPLICATION_JSON,
ResponsePayload responseMsg = new ResponsePayload(); httpMethod = "PUT",
org.wso2.carbon.policy.mgt.common.Policy policy = new org.wso2.carbon.policy.mgt.common.Policy(); value = "Updating a Policy.",
policy.setPolicyName(policyWrapper.getPolicyName()); notes = "If you wish to make changes to an existing policy, you can do so by updating the policy using " +
policy.setId(policyId); "this API")
policy.setProfileId(policyWrapper.getProfileId()); @ApiResponses(value = { @ApiResponse(code = 201, message = "Policy has been updated successfully."),
policy.setDescription(policyWrapper.getDescription()); @ApiResponse(code = 500, message = "Policy Management related exception in policy " +
policy.setProfile(DeviceMgtUtil.convertProfile(policyWrapper.getProfile())); "update") })
policy.setOwnershipType(policyWrapper.getOwnershipType()); Response updatePolicy(@ApiParam(name = "policyWrapper", value = "Policy details related to the operation.",
policy.setRoles(policyWrapper.getRoles()); required = true) PolicyWrapper policyWrapper,
policy.setUsers(policyWrapper.getUsers()); @ApiParam(name = "id", value = "Policy ID value to identify a policy uniquely.",
policy.setTenantId(policyWrapper.getTenantId()); required = true) @PathParam("id") int policyId);
policy.setCompliance(policyWrapper.getCompliance());
try {
PolicyAdministratorPoint pap = policyManagementService.getPAP();
pap.updatePolicy(policy);
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
responseMsg.setMessageFromServer("Policy has been updated successfully.");
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (PolicyManagementException e) {
String msg = "Policy Management related exception in policy update.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@PUT @PUT
@Path("priorities") @Path("priorities")
@Consumes({MediaType.APPLICATION_JSON}) @Consumes({MediaType.APPLICATION_JSON})
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response updatePolicyPriorities(List<PriorityUpdatedPolicyWrapper> priorityUpdatedPolicies) { @ApiOperation(
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); consumes = MediaType.APPLICATION_JSON,
List<org.wso2.carbon.policy.mgt.common.Policy> policiesToUpdate = produces = MediaType.APPLICATION_JSON,
new ArrayList<>(priorityUpdatedPolicies.size()); httpMethod = "PUT",
int i; value = "Updating the Policy Priority.",
for (i = 0; i < priorityUpdatedPolicies.size(); i++) { notes = "If you wish to make changes to the existing policy priority order, " +
org.wso2.carbon.policy.mgt.common.Policy policyObj = new org.wso2.carbon.policy.mgt.common.Policy(); "you can do so by updating the priority order using this API")
policyObj.setId(priorityUpdatedPolicies.get(i).getId()); @ApiResponses(value = { @ApiResponse(code = 200, message = "Policy Priorities successfully updated."),
policyObj.setPriorityId(priorityUpdatedPolicies.get(i).getPriority()); @ApiResponse(code = 400, message = "Policy priorities did not update."),
policiesToUpdate.add(policyObj); @ApiResponse(code = 500, message = "Error in updating policy priorities.") })
} Response updatePolicyPriorities(@ApiParam(name = "priorityUpdatedPolicies",
boolean policiesUpdated; value = "List of policy update details..",
try { required = true) List<PriorityUpdatedPolicyWrapper> priorityUpdatedPolicies);
PolicyAdministratorPoint pap = policyManagementService.getPAP();
policiesUpdated = pap.updatePolicyPriorities(policiesToUpdate);
} catch (PolicyManagementException e) {
String msg = "Exception in updating policy priorities.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
if (policiesUpdated) {
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Policy Priorities successfully updated.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
} else {
responsePayload.setStatusCode(HttpStatus.SC_BAD_REQUEST);
responsePayload.setMessageFromServer("Policy priorities did not update. Bad Request.");
return Response.status(Response.Status.BAD_REQUEST).entity(responsePayload).build();
}
}
@POST @POST
@Path("bulk-remove") @Path("bulk-remove")
@Consumes("application/json") @Consumes("application/json")
@Produces("application/json") @Produces("application/json")
public Response bulkRemovePolicy(List<Integer> policyIds) { @ApiOperation(
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); consumes = MediaType.APPLICATION_JSON,
boolean policyDeleted = true; produces = MediaType.APPLICATION_JSON,
try { httpMethod = "POST",
PolicyAdministratorPoint pap = policyManagementService.getPAP(); value = "Removing Multiple Policies.",
for(int i : policyIds) { notes = "In situations where you need to delete more than one policy you can do so using this API.")
org.wso2.carbon.policy.mgt.common.Policy policy = pap.getPolicy(i); @ApiResponses(value = { @ApiResponse(code = 200, message = "Policies have been successfully deleted."),
if(!pap.deletePolicy(policy)){ @ApiResponse(code = 400, message = "Policy does not exist."),
policyDeleted = false; @ApiResponse(code = 500, message = "Error in deleting policies.") })
} Response bulkRemovePolicy(@ApiParam(name = "policyIds", value = "Policy ID list to be deleted.",
} required = true) List<Integer> policyIds);
} catch (PolicyManagementException e) {
String msg = "Exception in deleting policies.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
if (policyDeleted) {
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Policies have been successfully deleted.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
} else {
responsePayload.setStatusCode(HttpStatus.SC_BAD_REQUEST);
responsePayload.setMessageFromServer("Policy does not exist.");
return Response.status(Response.Status.BAD_REQUEST).entity(responsePayload).build();
}
}
@PUT @PUT
@Produces("application/json") @Produces("application/json")
@Path("activate") @Path("activate")
public Response activatePolicy(List<Integer> policyIds) { @ApiOperation(
try { consumes = MediaType.APPLICATION_JSON,
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); produces = MediaType.APPLICATION_JSON,
PolicyAdministratorPoint pap = policyManagementService.getPAP(); httpMethod = "PUT",
for(int i : policyIds) { value = "Activating Policies.",
pap.activatePolicy(i); notes = "Using the REST API command you are able to publish a policy in order to bring a policy that is " +
} "in the inactive state to the active state.")
} catch (PolicyManagementException e) { @ApiResponses(value = { @ApiResponse(code = 200, message = "Policies have been successfully activated."),
String msg = "Exception in activating policies."; @ApiResponse(code = 500, message = "Error in activating policies.") })
log.error(msg, e); Response activatePolicy(@ApiParam(name = "policyIds", value = "Policy ID list to be activated.",
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); required = true) List<Integer> policyIds);
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Selected policies have been successfully activated.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@PUT @PUT
@Produces("application/json") @Produces("application/json")
@Path("inactivate") @Path("inactivate")
public Response inactivatePolicy(List<Integer> policyIds) throws MDMAPIException { @ApiOperation(
consumes = MediaType.APPLICATION_JSON,
try { produces = MediaType.APPLICATION_JSON,
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); httpMethod = "PUT",
PolicyAdministratorPoint pap = policyManagementService.getPAP(); value = "Deactivating Policies.",
for(int i : policyIds) { notes = "Using the REST API command you are able to unpublish a policy in order to bring a policy that " +
pap.inactivatePolicy(i); "is in the active state to the inactive state.")
} @ApiResponses(value = { @ApiResponse(code = 200, message = "Policies have been successfully deactivated."),
} catch (PolicyManagementException e) { @ApiResponse(code = 500, message = "Error in deactivating policies.") })
String msg = "Exception in inactivating policies."; Response inactivatePolicy(@ApiParam(name = "policyIds", value = "Policy ID list to be deactivated.",
log.error(msg, e); required = true) List<Integer> policyIds) throws MDMAPIException;
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Selected policies have been successfully inactivated.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@PUT @PUT
@Produces("application/json") @Produces("application/json")
@Path("apply-changes") @Path("apply-changes")
public Response applyChanges() { @ApiOperation(
consumes = MediaType.APPLICATION_JSON,
try { produces = MediaType.APPLICATION_JSON,
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); httpMethod = "PUT",
PolicyAdministratorPoint pap = policyManagementService.getPAP(); value = "Applying Changes on Policies.",
pap.publishChanges(); notes = "Policies in the active state will be applied to new device that register with WSO2 EMM based on" +
" the policy enforcement criteria . In a situation where you need to make changes to existing" +
" policies (removing, activating, deactivating and updating) or add new policies, the existing" +
} catch (PolicyManagementException e) { " devices will not receive these changes immediately. Once all the required changes are made" +
String msg = "Exception in applying changes."; " you need to apply the changes to push the policy changes to the existing devices.")
log.error(msg, e); @ApiResponses(value = { @ApiResponse(code = 200, message = "Changes have been successfully updated."),
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); @ApiResponse(code = 500, message = "Error in updating policies.") })
} Response applyChanges();
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Changes have been successfully updated.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@GET @GET
@Path("start-task/{milliseconds}") @Path("start-task/{milliseconds}")
public Response startTaskService(@PathParam("milliseconds") int monitoringFrequency) { @ApiOperation(
consumes = MediaType.APPLICATION_JSON,
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); produces = MediaType.APPLICATION_JSON,
try { httpMethod = "GET",
TaskScheduleService taskScheduleService = policyManagementService.getTaskScheduleService(); value = "Starting Policy Monitoring.",
taskScheduleService.startTask(monitoringFrequency); notes = "WSO2 EMM monitors the devices to identify any devices that have not complied to an enforced " +
"policy. The policy monitoring task begins at the point WSO2 EMM has a a published policy. " +
"It will monitor the device based on the policy monitoring frequency that you define in " +
} catch (PolicyMonitoringTaskException e) { "milliseconds.Using this REST API to start the policy monitoring task is optional as " +
String msg = "Policy Management related exception."; "WSO2 EMM uses an OSGI call to start the monitoring task")
log.error(msg, e); @ApiResponses(value = { @ApiResponse(code = 200, message = "Policy monitoring service started successfully."),
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); @ApiResponse(code = 500, message = "Policy Management related exception when starting " +
} "monitoring service.") })
ResponsePayload responsePayload = new ResponsePayload(); Response startTaskService(@ApiParam(name = "milliseconds", value = "Policy monitoring frequency in milliseconds.",
responsePayload.setStatusCode(HttpStatus.SC_OK); required = true) @PathParam("milliseconds") int monitoringFrequency);
responsePayload.setMessageFromServer("Policy monitoring service started successfully.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@GET @GET
@Path("update-task/{milliseconds}") @Path("update-task/{milliseconds}")
public Response updateTaskService(@PathParam("milliseconds") int monitoringFrequency) { Response updateTaskService(@PathParam("milliseconds") int monitoringFrequency);
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
try {
TaskScheduleService taskScheduleService = policyManagementService.getTaskScheduleService();
taskScheduleService.updateTask(monitoringFrequency);
} catch (PolicyMonitoringTaskException e) {
String msg = "Policy Management related exception.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Policy monitoring service updated successfully.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@GET @GET
@Path("stop-task") @Path("stop-task")
public Response stopTaskService() { Response stopTaskService();
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
try {
TaskScheduleService taskScheduleService = policyManagementService.getTaskScheduleService();
taskScheduleService.stopTask();
} catch (PolicyMonitoringTaskException e) {
String msg = "Policy Management related exception.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Policy monitoring service stopped successfully.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@GET @GET
@Path("{type}/{id}") @Path("{type}/{id}")
public Response getComplianceDataOfDevice(@PathParam("type") String type, @PathParam("id") String id) { Response getComplianceDataOfDevice(@PathParam("type") String type, @PathParam("id") String id);
try {
DeviceIdentifier deviceIdentifier = DeviceMgtAPIUtils.instantiateDeviceIdentifier(type, id);
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
ComplianceData complianceData = policyManagementService.getDeviceCompliance(deviceIdentifier);
return Response.status(Response.Status.OK).entity(complianceData).build();
} catch (PolicyComplianceException e) {
String msg = "Error occurred while getting the compliance data.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@GET @GET
@Path("{type}/{id}/active-policy") @Path("{type}/{id}/active-policy")
public Response getDeviceActivePolicy(@PathParam("type") String type, @ApiOperation(
@PathParam("id") String id) { consumes = MediaType.APPLICATION_JSON,
try { produces = MediaType.APPLICATION_JSON,
DeviceIdentifier deviceIdentifier = DeviceMgtAPIUtils.instantiateDeviceIdentifier(type, id); httpMethod = "GET",
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); value = "Getting Policy Enforced Details of a Device.",
org.wso2.carbon.policy.mgt.common.Policy policy = policyManagementService notes = "When a device registers with WSO2 EMM a policy is enforced on the device. Initially the EMM " +
.getAppliedPolicyToDevice(deviceIdentifier); "filters the policies based on the Platform (device type), filters based on the device ownership" +
return Response.status(Response.Status.OK).entity(policy).build(); " type , filters based on the user role or name and finally the policy is enforced on the device.")
} catch (PolicyManagementException e) { @ApiResponses(value = { @ApiResponse(code = 200, message = "Fetched current policy."),
String msg = "Error occurred while getting the current policy."; @ApiResponse(code = 500, message = "Error occurred while getting the current policy.") })
log.error(msg, e); Response getDeviceActivePolicy(@ApiParam(name = "type", value = "Define the device type as the value for {type}." +
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); " Example: ios, android, windows..",
} required = true) @PathParam("type") String type,
} @ApiParam(name = "id", value = "Define the device ID as the value for {id}.",
required = true) @PathParam("id") String id);
} }

@ -18,13 +18,7 @@
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.logging.Log; import io.swagger.annotations.Api;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.policy.mgt.common.PolicyAdministratorPoint;
import org.wso2.carbon.policy.mgt.common.PolicyManagementException;
import org.wso2.carbon.policy.mgt.core.PolicyManagerService;
import javax.ws.rs.DELETE; import javax.ws.rs.DELETE;
import javax.ws.rs.POST; import javax.ws.rs.POST;
@ -32,55 +26,22 @@ import javax.ws.rs.Path;
import javax.ws.rs.PathParam; import javax.ws.rs.PathParam;
import javax.ws.rs.core.Response; import javax.ws.rs.core.Response;
/**
* These end points provide profile related operations.
*/
@Api(value = "Profile")
@SuppressWarnings("NonJaxWsWebServices") @SuppressWarnings("NonJaxWsWebServices")
public class Profile { public interface Profile {
private static Log log = LogFactory.getLog(Profile.class);
@POST
Response addProfile(org.wso2.carbon.policy.mgt.common.Profile profile);
@POST
@Path("{id}")
Response updateProfile(org.wso2.carbon.policy.mgt.common.Profile profile,
@PathParam("id") String profileId);
@POST @DELETE
public Response addProfile(org.wso2.carbon.policy.mgt.common.Profile profile) { @Path("{id}")
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService(); Response deleteProfile(@PathParam("id") int profileId);
try {
PolicyAdministratorPoint pap = policyManagementService.getPAP();
profile = pap.addProfile(profile);
return Response.status(Response.Status.OK).entity(profile).build();
} catch (PolicyManagementException e) {
String msg = "Policy Management related exception";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@POST
@Path("{id}")
public Response updateProfile(org.wso2.carbon.policy.mgt.common.Profile profile,
@PathParam("id") String profileId) {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
ResponsePayload responseMsg = new ResponsePayload();
try {
PolicyAdministratorPoint pap = policyManagementService.getPAP();
pap.updateProfile(profile);
responseMsg.setMessageFromServer("Profile has been updated successfully.");
return Response.status(Response.Status.OK).entity(responseMsg).build();
} catch (PolicyManagementException e) {
String msg = "Policy Management related exception";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@DELETE
@Path("{id}")
public Response deleteProfile(@PathParam("id") int profileId) {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
ResponsePayload responseMsg = new ResponsePayload();
try {
PolicyAdministratorPoint pap = policyManagementService.getPAP();
org.wso2.carbon.policy.mgt.common.Profile profile = pap.getProfile(profileId);
pap.deleteProfile(profile);
responseMsg.setMessageFromServer("Profile has been deleted successfully.");
return Response.status(Response.Status.OK).entity(responseMsg).build();
} catch (PolicyManagementException e) {
String msg = "Policy Management related exception";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
} }

@ -18,25 +18,11 @@
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.httpclient.HttpStatus; import io.swagger.annotations.*;
import org.apache.commons.logging.Log; import org.wso2.carbon.device.mgt.common.app.mgt.Application;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.CarbonConstants;
import org.wso2.carbon.base.MultitenantConstants;
import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload; import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.device.mgt.jaxrs.beans.RoleWrapper; import org.wso2.carbon.device.mgt.jaxrs.beans.RoleWrapper;
import org.wso2.carbon.device.mgt.jaxrs.util.SetReferenceTransformer;
import org.wso2.carbon.user.api.AuthorizationManager;
import org.wso2.carbon.user.api.Permission;
import org.wso2.carbon.user.api.UserRealm;
import org.wso2.carbon.user.api.UserStoreException;
import org.wso2.carbon.user.api.UserStoreManager;
import org.wso2.carbon.user.core.common.AbstractUserStoreManager;
import org.wso2.carbon.user.mgt.UserRealmProxy;
import org.wso2.carbon.user.mgt.common.UIPermissionNode; import org.wso2.carbon.user.mgt.common.UIPermissionNode;
import org.wso2.carbon.user.mgt.common.UserAdminException;
import javax.ws.rs.DELETE; import javax.ws.rs.DELETE;
import javax.ws.rs.GET; import javax.ws.rs.GET;
@ -48,393 +34,178 @@ 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.util.ArrayList;
import java.util.Arrays;
import java.util.List; import java.util.List;
@SuppressWarnings("NonJaxWsWebServices") /**
public class Role { *
*/
private static Log log = LogFactory.getLog(Role.class); @Api(value = "Role")
public interface Role {
/**
* Get user roles (except all internal roles) from system.
*
* @return A list of users
*/
@GET @GET
@Produces({MediaType.APPLICATION_JSON}) @Produces({ MediaType.APPLICATION_JSON})
public Response getRoles() { @ApiOperation(
List<String> filteredRoles; consumes = MediaType.APPLICATION_JSON,
try { produces = MediaType.APPLICATION_JSON,
filteredRoles = getRolesFromUserStore(); httpMethod = "GET",
} catch (MDMAPIException e) { value = "Getting the List of Roles.",
log.error(e.getErrorMessage(), e); responseContainer = "List",
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getErrorMessage()).build(); notes = "If you wish to get the details of all the roles in WSO2 EMM, you can do so using this REST API.",
} response = String.class)
ResponsePayload responsePayload = new ResponsePayload(); @ApiResponses(value = { @ApiResponse(code = 200, message = "List of available roles"),
responsePayload.setStatusCode(HttpStatus.SC_OK); @ApiResponse(code = 500, message = "Error occurred while fetching the role list.") })
responsePayload.setMessageFromServer("All user roles were successfully retrieved."); Response getRoles();
responsePayload.setResponseContent(filteredRoles);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get user roles by user store(except all internal roles) from system.
*
* @return A list of users
*/
@GET @GET
@Path("{userStore}") @Path("{userStore}")
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response getRoles(@PathParam("userStore") String userStore) { @ApiOperation(
String[] roles; consumes = MediaType.APPLICATION_JSON,
try { produces = MediaType.APPLICATION_JSON,
AbstractUserStoreManager abstractUserStoreManager = httpMethod = "GET",
(AbstractUserStoreManager) DeviceMgtAPIUtils.getUserStoreManager(); value = "Getting the List of Roles in a User Store.",
if (log.isDebugEnabled()) { responseContainer = "List",
log.debug("Getting the list of user roles"); notes = "If you wish to get the details of all the roles in WSO2 EMM, you can do so using this REST API.",
} response = String.class)
roles = abstractUserStoreManager.getRoleNames(userStore + "/*", -1, false, true, true); @ApiResponses(value = { @ApiResponse(code = 200, message = "List of available roles"),
@ApiResponse(code = 500, message = "Error occurred while fetching the role list.") })
Response getRoles(@ApiParam(name = "userStore", value = "Provide the name of the UserStore you wish to get the" +
" details from ",
required = true) @PathParam("userStore") String userStore);
} catch (UserStoreException | MDMAPIException e) {
String msg = "Error occurred while retrieving the list of user roles.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
// removing all internal roles and roles created for Service-providers
List<String> filteredRoles = new ArrayList<>();
for (String role : roles) {
if (!(role.startsWith("Internal/") || role.startsWith("Application/"))) {
filteredRoles.add(role);
}
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("All user roles were successfully retrieved.");
responsePayload.setResponseContent(filteredRoles);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get user roles by providing a filtering criteria(except all internal roles & system roles) from system.
*
* @return A list of users
*/
@GET @GET
@Path("search") @Path("search")
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response getMatchingRoles(@QueryParam("filter") String filter) { @ApiOperation(
String[] roles; consumes = MediaType.APPLICATION_JSON,
try { produces = MediaType.APPLICATION_JSON,
AbstractUserStoreManager abstractUserStoreManager = httpMethod = "GET",
(AbstractUserStoreManager) DeviceMgtAPIUtils.getUserStoreManager(); value = "Searching for Roles via the Role Name.",
if (log.isDebugEnabled()) { responseContainer = "List",
log.debug("Getting the list of user roles using filter : " + filter); notes = "You will have many roles created within WSO2 EMM. As the admin you will need to confirm if a " +
} "given role exists in the EMM. In such situation you can search for the role by giving a " +
roles = abstractUserStoreManager.getRoleNames("*" + filter + "*", -1, true, true, true); "character or a few characters of the role name. The search will give you a list of roles that" +
" have the name in the exact order of the characters you provided.",
} catch (UserStoreException | MDMAPIException e) { response = String.class)
String msg = "Error occurred while retrieving the list of user roles using the filter : " + filter; @ApiResponses(value = { @ApiResponse(code = 200, message = "List of matching roles"),
log.error(msg, e); @ApiResponse(code = 500, message = "Error occurred while fetching the matching role list" +
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); ".") })
} Response getMatchingRoles(@ApiParam(name = "filter", value = "Provide a character or a few characters in the" +
// removing all internal roles and roles created for Service-providers " role name.",
List<String> filteredRoles = new ArrayList<>(); required = true) @QueryParam("filter") String filter);
for (String role : roles) {
if (!(role.startsWith("Internal/") || role.startsWith("Application/"))) {
filteredRoles.add(role);
}
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("All matching user roles were successfully retrieved.");
responsePayload.setResponseContent(filteredRoles);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get role permissions.
*
* @return list of permissions
*/
@GET @GET
@Path("permissions") @Path("permissions")
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response getPermissions(@QueryParam("rolename") String roleName) { @ApiOperation(
try { consumes = MediaType.APPLICATION_JSON,
final UserRealm userRealm = DeviceMgtAPIUtils.getUserRealm(); produces = MediaType.APPLICATION_JSON,
org.wso2.carbon.user.core.UserRealm userRealmCore = null; httpMethod = "GET",
final UIPermissionNode rolePermissions; value = "Getting Permission Details of a Role.",
if (userRealm instanceof org.wso2.carbon.user.core.UserRealm) { notes = "In an organization an individual is associated a with set of responsibilities based on their " +
userRealmCore = (org.wso2.carbon.user.core.UserRealm) userRealm; "role. In WSO2 EMM you are able to configure permissions based on the responsibilities carried " +
} "out by a role. Therefore if you wish to retrieve the permission details of a role, you can do " +
final UserRealmProxy userRealmProxy = new UserRealmProxy(userRealmCore); "so using this REST API.",
rolePermissions = getUIPermissionNode(roleName, userRealmProxy); response = UIPermissionNode.class)
ResponsePayload responsePayload = new ResponsePayload(); @ApiResponses(value = { @ApiResponse(code = 200, message = "Permission details of a role"),
responsePayload.setStatusCode(HttpStatus.SC_OK); @ApiResponse(code = 500, message = "Error occurred while fetching the permission " +
responsePayload.setMessageFromServer("All permissions retrieved"); "details of a role.") })
responsePayload.setResponseContent(rolePermissions); Response getPermissions(@ApiParam(name = "rolename", value = "Provide the name of the role you wish to get the " +
return Response.status(Response.Status.OK).entity(responsePayload).build(); "permission details.",
} catch (UserAdminException | MDMAPIException e) { required = true) @QueryParam("rolename") String roleName);
String msg = "Error occurred while retrieving the user role";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Get user role of the system
*
* @return user role
*/
@GET @GET
@Path("role") @Path("role")
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response getRole(@QueryParam("rolename") String roleName) { @ApiOperation(
RoleWrapper roleWrapper = new RoleWrapper(); consumes = MediaType.APPLICATION_JSON,
try { produces = MediaType.APPLICATION_JSON,
final UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); httpMethod = "GET",
final UserRealm userRealm = DeviceMgtAPIUtils.getUserRealm(); value = "Getting Details of a Role.",
org.wso2.carbon.user.core.UserRealm userRealmCore = null; notes = "If you wish to get the details of a role in WSO2 EMM, you can do so using this REST API.",
if (userRealm instanceof org.wso2.carbon.user.core.UserRealm) { response = RoleWrapper.class)
userRealmCore = (org.wso2.carbon.user.core.UserRealm) userRealm; @ApiResponses(value = { @ApiResponse(code = 200, message = "Details of a role."),
} @ApiResponse(code = 500, message = "Error occurred while retrieving the user role.") })
Response getRole(@ApiParam(name = "rolename", value = "Provide the name of the role you wish to get the " +
final UserRealmProxy userRealmProxy = new UserRealmProxy(userRealmCore); "details.",
if (log.isDebugEnabled()) { required = true) @QueryParam("rolename") String roleName);
log.debug("Getting the list of user roles");
}
if (userStoreManager.isExistingRole(roleName)) {
roleWrapper.setRoleName(roleName);
roleWrapper.setUsers(userStoreManager.getUserListOfRole(roleName));
// Get the permission nodes and hand picking only device management and login perms
final UIPermissionNode rolePermissions = getUIPermissionNode(roleName, userRealmProxy);
ArrayList<String> permList = new ArrayList<>();
iteratePermissions(rolePermissions, permList);
roleWrapper.setPermissionList(rolePermissions);
String[] permListAr = new String[permList.size()];
roleWrapper.setPermissions(permList.toArray(permListAr));
}
} catch (UserStoreException | UserAdminException | MDMAPIException e) {
String msg = "Error occurred while retrieving the user role";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("All user roles were successfully retrieved.");
responsePayload.setResponseContent(roleWrapper);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
private UIPermissionNode getUIPermissionNode(String roleName, UserRealmProxy userRealmProxy)
throws UserAdminException {
final UIPermissionNode rolePermissions =
userRealmProxy.getRolePermissions(roleName, MultitenantConstants.SUPER_TENANT_ID);
UIPermissionNode[] deviceMgtPermissions = new UIPermissionNode[2];
for (UIPermissionNode permissionNode : rolePermissions.getNodeList()) {
if (permissionNode.getResourcePath().equals("/permission/admin")) {
for (UIPermissionNode node : permissionNode.getNodeList()) {
if (node.getResourcePath().equals("/permission/admin/device-mgt")) {
deviceMgtPermissions[0] = node;
} else if (node.getResourcePath().equals("/permission/admin/login")) {
deviceMgtPermissions[1] = node;
}
}
}
}
rolePermissions.setNodeList(deviceMgtPermissions);
return rolePermissions;
}
/**
* API is used to persist a new Role
*
* @param roleWrapper for role
* @return response
*/
@POST @POST
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response addRole(RoleWrapper roleWrapper) { @ApiOperation(
try { consumes = MediaType.APPLICATION_JSON,
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); produces = MediaType.APPLICATION_JSON,
if (log.isDebugEnabled()) { httpMethod = "POST",
log.debug("Persisting the role to user store"); value = "Adding a Role.",
} notes = "You are able to add a new role to WSO2 EMM using the REST API.")
Permission[] permissions = null; @ApiResponses(value = { @ApiResponse(code = 200, message = "Added the role."),
if (roleWrapper.getPermissions() != null && roleWrapper.getPermissions().length > 0) { @ApiResponse(code = 500, message = "Error occurred while adding the user role.") })
permissions = new Permission[roleWrapper.getPermissions().length]; Response addRole(@ApiParam(name = "roleWrapper", value = "Role and permission details.",
required = true) RoleWrapper roleWrapper);
for (int i = 0; i < permissions.length; i++) {
String permission = roleWrapper.getPermissions()[i];
permissions[i] = new Permission(permission, CarbonConstants.UI_PERMISSION_ACTION);
}
}
userStoreManager.addRole(roleWrapper.getRoleName(), roleWrapper.getUsers(), permissions);
} catch (UserStoreException | MDMAPIException e) {
String msg = e.getMessage();
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).build();
}
/**
* API is used to update a role Role
*
* @param roleWrapper for role
* @return response
*/
@PUT @PUT
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response updateRole(@QueryParam("rolename") String roleName, RoleWrapper roleWrapper) { @ApiOperation(
String newRoleName = roleWrapper.getRoleName(); consumes = MediaType.APPLICATION_JSON,
try { produces = MediaType.APPLICATION_JSON,
final UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); httpMethod = "PUT",
final AuthorizationManager authorizationManager = DeviceMgtAPIUtils.getAuthorizationManager(); value = "Updating a Role.",
if (log.isDebugEnabled()) { notes = "There will be situations where you will need to update the role details, such as the permissions" +
log.debug("Updating the role to user store"); " or the role name. In such situation you can update the role details.")
} @ApiResponses(value = { @ApiResponse(code = 200, message = "Updated the role."),
if (newRoleName != null && !roleName.equals(newRoleName)) { @ApiResponse(code = 500, message = "Error occurred while updating the user role details" +
userStoreManager.updateRoleName(roleName, newRoleName); ".") })
} Response updateRole(@ApiParam(name = "rolename", value = "Provide the name of the role you wish to update.",
if (roleWrapper.getUsers() != null) { required = true) @QueryParam("rolename") String roleName,
SetReferenceTransformer<String> transformer = new SetReferenceTransformer<>(); @ApiParam(name = "roleWrapper", value = "Role and permission details.",
transformer.transform(Arrays.asList(userStoreManager.getUserListOfRole(newRoleName)), required = true) RoleWrapper roleWrapper);
Arrays.asList(roleWrapper.getUsers()));
final String[] usersToAdd = transformer.getObjectsToAdd().toArray(new String[transformer
.getObjectsToAdd().size()]);
final String[] usersToDelete = transformer.getObjectsToRemove().toArray(new String[transformer
.getObjectsToRemove().size()]);
userStoreManager.updateUserListOfRole(newRoleName, usersToDelete, usersToAdd);
}
if (roleWrapper.getPermissions() != null) {
// Delete all authorizations for the current role before authorizing the permission tree
authorizationManager.clearRoleAuthorization(roleName);
if (roleWrapper.getPermissions().length > 0) {
for (int i = 0; i < roleWrapper.getPermissions().length; i++) {
String permission = roleWrapper.getPermissions()[i];
authorizationManager.authorizeRole(roleName, permission, CarbonConstants.UI_PERMISSION_ACTION);
}
}
}
} catch (UserStoreException | MDMAPIException e) {
String msg = e.getMessage();
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).build();
}
/**
* API is used to delete a role and authorizations
*
* @param roleName to delete
* @return response
*/
@DELETE @DELETE
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response deleteRole(@QueryParam("rolename") String roleName) { @ApiOperation(
try { consumes = MediaType.APPLICATION_JSON,
final UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); produces = MediaType.APPLICATION_JSON,
final AuthorizationManager authorizationManager = DeviceMgtAPIUtils.getAuthorizationManager(); httpMethod = "DELETE",
if (log.isDebugEnabled()) { value = "Deleting a Role.",
log.debug("Deleting the role in user store"); notes = "In a situation when your Organization identifies that a specific role is no longer required you " +
} "will need to remove the role details from WSO2 EMM.")
userStoreManager.deleteRole(roleName); @ApiResponses(value = { @ApiResponse(code = 200, message = "Deleted the role."),
// Delete all authorizations for the current role before deleting @ApiResponse(code = 500, message = "Error occurred while deleting the user role details" +
authorizationManager.clearRoleAuthorization(roleName); ".") })
} catch (UserStoreException | MDMAPIException e) { Response deleteRole(@ApiParam(name = "rolename", value = "Provide the name of the role you wish to delete.",
String msg = "Error occurred while deleting the role: " + roleName; required = true) @QueryParam("rolename") String roleName);
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).build();
}
/**
* API is used to update users of a role
*
* @param roleName to update
* @param userList of the users
* @return response
*/
@PUT @PUT
@Path("users") @Path("users")
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response updateUsers(@QueryParam("rolename") String roleName, List<String> userList) { @ApiOperation(
try { consumes = MediaType.APPLICATION_JSON,
final UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); produces = MediaType.APPLICATION_JSON,
if (log.isDebugEnabled()) { httpMethod = "PUT",
log.debug("Updating the users of a role"); value = "Adding Users to a Role.",
} notes = "Defining the users to a role at the point of creating a new role is optional, " +
SetReferenceTransformer<String> transformer = new SetReferenceTransformer<>(); "therefore you are able to update the users that belong to a given role after you have created " +
transformer.transform(Arrays.asList(userStoreManager.getUserListOfRole(roleName)), "a role using this REST API." +
userList); "Example: Your Organization hires 30 new engineers. Updating the role details for each user can " +
final String[] usersToAdd = transformer.getObjectsToAdd().toArray(new String[transformer "be cumbersome, therefore you can define all the new employees that belong to the engineering " +
.getObjectsToAdd().size()]); "role using this API.")
final String[] usersToDelete = transformer.getObjectsToRemove().toArray(new String[transformer @ApiResponses(value = { @ApiResponse(code = 200, message = "Added Users to a Role."),
.getObjectsToRemove().size()]); @ApiResponse(code = 500, message = "Error occurred while saving the users of the role.") })
Response updateUsers(@ApiParam(name = "rolename", value = "Provide the name of the role you wish to update.",
userStoreManager.updateUserListOfRole(roleName, usersToDelete, usersToAdd); required = true) @QueryParam("rolename") String roleName,
} catch (UserStoreException | MDMAPIException e) { @ApiParam(name = "userList", value = "Provide the names of the users you will to update.",
String msg = "Error occurred while saving the users of the role: " + roleName; required = true) List<String> userList);
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).build();
}
private ArrayList<String> iteratePermissions(UIPermissionNode uiPermissionNode, ArrayList<String> list) {
for (UIPermissionNode permissionNode : uiPermissionNode.getNodeList()) {
list.add(permissionNode.getResourcePath());
if (permissionNode.getNodeList() != null && permissionNode.getNodeList().length > 0) {
iteratePermissions(permissionNode, list);
}
}
return list;
}
/**
* This method is used to retrieve the role count of the system.
*
* @return returns the count.
*/
@GET @GET
@Path("count") @Path("count")
public Response getRoleCount() { @ApiOperation(
try { consumes = MediaType.APPLICATION_JSON,
List<String> filteredRoles = getRolesFromUserStore(); produces = MediaType.APPLICATION_JSON,
Integer count = filteredRoles.size(); httpMethod = "GET",
return Response.status(Response.Status.OK).entity(count).build(); value = "Getting the Role Count.",
} catch (MDMAPIException e) { response = Integer.class,
log.error(e.getErrorMessage(), e); notes = "Get the number of roles in WSO2 EMM.")
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getErrorMessage()).build(); @ApiResponses(value = { @ApiResponse(code = 200, message = "Retrieved the role count."),
} @ApiResponse(code = 500, message = "Error occurred while retrieving the role count.") })
} Response getRoleCount();
private List<String> getRolesFromUserStore() throws MDMAPIException {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
String[] roles;
try {
if (log.isDebugEnabled()) {
log.debug("Getting the list of user roles");
}
roles = userStoreManager.getRoleNames();
} catch (UserStoreException e) {
String msg = "Error occurred while retrieving the list of user roles.";
throw new MDMAPIException(msg, e);
}
// removing all internal roles and roles created for Service-providers
List<String> filteredRoles = new ArrayList<>();
for (String role : roles) {
if (!(role.startsWith("Internal/") || role.startsWith("Application/"))) {
filteredRoles.add(role);
}
}
return filteredRoles;
}
} }

@ -18,27 +18,15 @@
package org.wso2.carbon.device.mgt.jaxrs.api; package org.wso2.carbon.device.mgt.jaxrs.api;
import org.apache.commons.codec.binary.Base64; import io.swagger.annotations.Api;
import org.apache.commons.httpclient.HttpStatus; import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang.StringUtils; import io.swagger.annotations.ApiParam;
import org.apache.commons.logging.Log; import io.swagger.annotations.ApiResponse;
import org.apache.commons.logging.LogFactory; import io.swagger.annotations.ApiResponses;
import org.wso2.carbon.context.CarbonContext; import org.apache.axis2.databinding.types.soapencoding.Integer;
import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException; import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.device.mgt.jaxrs.beans.UserCredentialWrapper; import org.wso2.carbon.device.mgt.jaxrs.beans.UserCredentialWrapper;
import org.wso2.carbon.device.mgt.jaxrs.beans.UserWrapper; import org.wso2.carbon.device.mgt.jaxrs.beans.UserWrapper;
import org.wso2.carbon.device.mgt.jaxrs.util.Constants;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.PaginationRequest;
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
import org.wso2.carbon.device.mgt.core.service.EmailMetaInfo;
import org.wso2.carbon.device.mgt.jaxrs.api.util.CredentialManagementResponseBuilder;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.device.mgt.jaxrs.util.SetReferenceTransformer;
import org.wso2.carbon.user.api.UserStoreException;
import org.wso2.carbon.user.api.UserStoreManager;
import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
import javax.ws.rs.Consumes; import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE; import javax.ws.rs.DELETE;
@ -51,707 +39,279 @@ 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.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Random;
import java.util.TreeSet;
/** /**
* This class represents the JAX-RS services of User related functionality. * This represents the JAX-RS services of User related functionality.
*/ */
@SuppressWarnings("NonJaxWsWebServices") @Api(value = "User")
public class User { public interface User {
private static final String ROLE_EVERYONE = "Internal/everyone";
private static Log log = LogFactory.getLog(User.class);
/**
* Method to add user to emm-user-store.
*
* @param userWrapper Wrapper object representing input json payload
* @return {Response} Status of the request wrapped inside Response object
*/
@POST @POST
@Consumes({MediaType.APPLICATION_JSON}) @Consumes({ MediaType.APPLICATION_JSON})
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response addUser(UserWrapper userWrapper) { @ApiOperation(
ResponsePayload responsePayload = new ResponsePayload(); consumes = MediaType.APPLICATION_JSON,
try { produces = MediaType.APPLICATION_JSON,
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); httpMethod = "POST",
if (userStoreManager.isExistingUser(userWrapper.getUsername())) { value = "Adding a User via the REST API",
// if user already exists notes = "Adds a new user to WSO2 EMM using this REST API")
if (log.isDebugEnabled()) { @ApiResponses(value = {
log.debug("User by username: " + userWrapper.getUsername() + @ApiResponse(code = 201, message = "Created"),
" already exists. Therefore, request made to add user was refused."); @ApiResponse(code = 500, message = "Exception in trying to add user by username: 'username'")
} })
// returning response with bad request state Response addUser(@ApiParam(name = "userWrapper", value = "Includes the required properties to add a user"
responsePayload.setStatusCode(HttpStatus.SC_CONFLICT); + " as the <JSON_PAYLOAD> value", required = true) UserWrapper userWrapper);
responsePayload.
setMessageFromServer("User by username: " + userWrapper.getUsername() +
" already exists. Therefore, request made to add user was refused.");
return Response.status(Response.Status.CONFLICT).entity(responsePayload).build();
} else {
String initialUserPassword = generateInitialUserPassword();
Map<String, String> defaultUserClaims =
buildDefaultUserClaims(userWrapper.getFirstname(), userWrapper.getLastname(),
userWrapper.getEmailAddress());
// calling addUser method of carbon user api
userStoreManager.addUser(userWrapper.getUsername(), initialUserPassword,
userWrapper.getRoles(), defaultUserClaims, null);
// invite newly added user to enroll device
inviteNewlyAddedUserToEnrollDevice(userWrapper.getUsername(), initialUserPassword);
// Outputting debug message upon successful addition of user
if (log.isDebugEnabled()) {
log.debug("User by username: " + userWrapper.getUsername() + " was successfully added.");
}
// returning response with success state
responsePayload.setStatusCode(HttpStatus.SC_CREATED);
responsePayload.setMessageFromServer("User by username: " + userWrapper.getUsername() +
" was successfully added.");
return Response.status(Response.Status.CREATED).entity(responsePayload).build();
}
} catch (UserStoreException | MDMAPIException e) {
String msg = "Exception in trying to add user by username: " + userWrapper.getUsername();
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Method to get user information from emm-user-store.
*
* @param username User-name of the user
* @return {Response} Status of the request wrapped inside Response object.
*/
@GET @GET
@Path("view") @Path("view")
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response getUser(@QueryParam("username") String username) { @ApiOperation(
ResponsePayload responsePayload = new ResponsePayload(); produces = MediaType.APPLICATION_JSON,
try { httpMethod = "GET",
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); value = "Getting Details of a User",
if (userStoreManager.isExistingUser(username)) { notes = "If you wish to get the details of a specific user that is registered with WSO2 EMM,"
UserWrapper user = new UserWrapper(); + " you can do so using the REST API",
user.setUsername(username); response = UserWrapper.class)
user.setEmailAddress(getClaimValue(username, Constants.USER_CLAIM_EMAIL_ADDRESS)); @ApiResponses(value = {
user.setFirstname(getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME)); @ApiResponse(code = 201, message = "User information was retrieved successfully"),
user.setLastname(getClaimValue(username, Constants.USER_CLAIM_LAST_NAME)); @ApiResponse(code = 400, message = "User by username: 'username' does not exist"),
// Outputting debug message upon successful retrieval of user @ApiResponse(code = 500, message = "Exception in trying to retrieve user by username: 'username'")
if (log.isDebugEnabled()) { })
log.debug("User by username: " + username + " was found."); Response getUser(@ApiParam(name = "username", value = "Provide the name of the user you wish to get the"
} + " details of as the value", required = true)
responsePayload.setStatusCode(HttpStatus.SC_OK); @QueryParam("username") String username);
responsePayload.setMessageFromServer("User information was retrieved successfully.");
responsePayload.setResponseContent(user);
return Response.status(Response.Status.OK).entity(responsePayload).build();
} else {
// Outputting debug message upon trying to remove non-existing user
if (log.isDebugEnabled()) {
log.debug("User by username: " + username + " does not exist.");
}
// returning response with bad request state
responsePayload.setStatusCode(HttpStatus.SC_BAD_REQUEST);
responsePayload.setMessageFromServer(
"User by username: " + username + " does not exist.");
return Response.status(Response.Status.BAD_REQUEST).entity(responsePayload).build();
}
} catch (UserStoreException | MDMAPIException e) {
String msg = "Exception in trying to retrieve user by username: " + username;
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Update user in user store
*
* @param userWrapper Wrapper object representing input json payload
* @return {Response} Status of the request wrapped inside Response object.
*/
@PUT @PUT
@Consumes({MediaType.APPLICATION_JSON}) @Consumes({MediaType.APPLICATION_JSON})
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response updateUser(UserWrapper userWrapper, @QueryParam("username") String username) { @ApiOperation(
ResponsePayload responsePayload = new ResponsePayload(); consumes = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
try { produces = MediaType.APPLICATION_JSON + ", " + MediaType.APPLICATION_XML,
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); httpMethod = "PUT",
if (userStoreManager.isExistingUser(userWrapper.getUsername())) { value = "Updating Details of a User",
Map<String, String> defaultUserClaims = notes = "There will be situations where you will want to update the user details. In such "
buildDefaultUserClaims(userWrapper.getFirstname(), userWrapper.getLastname(), + "situation you can update the user details using this REST API")
userWrapper.getEmailAddress()); @ApiResponses(value = {
if (StringUtils.isNotEmpty(userWrapper.getPassword())) { @ApiResponse(code = 200, message = "User by username: 'username' was successfully updated"),
// Decoding Base64 encoded password @ApiResponse(code = 409, message = "User by username: 'username' doesn't exists. Therefore, "
byte[] decodedBytes = Base64.decodeBase64(userWrapper.getPassword()); + "request made to update user was refused"),
userStoreManager.updateCredentialByAdmin(userWrapper.getUsername(), @ApiResponse(code = 500, message = "Exception in trying to update user by username: 'username'")
new String(decodedBytes, "UTF-8")); })
log.debug("User credential of username: " + userWrapper.getUsername() + " has been changed"); Response updateUser(@ApiParam(name = "userWrapper", value = "Provide the name of the user you wish to get"
} + " the details of as the value", required = true) UserWrapper userWrapper,
List<String> listofFilteredRoles = getFilteredRoles(userStoreManager, userWrapper.getUsername()); @ApiParam(name = "username", value = "Provide the name of the user you wish to get "
final String[] existingRoles = listofFilteredRoles.toArray(new String[listofFilteredRoles.size()]); + "the details of as the value", required = true)
@QueryParam("username") String username);
/*
Use the Set theory to find the roles to delete and roles to add
The difference of roles in existingRolesSet and newRolesSet needed to be deleted
new roles to add = newRolesSet - The intersection of roles in existingRolesSet and newRolesSet
*/
final TreeSet<String> existingRolesSet = new TreeSet<>();
Collections.addAll(existingRolesSet, existingRoles);
final TreeSet<String> newRolesSet = new TreeSet<>();
Collections.addAll(newRolesSet, userWrapper.getRoles());
existingRolesSet.removeAll(newRolesSet);
// Now we have the roles to delete
String[] rolesToDelete = existingRolesSet.toArray(new String[existingRolesSet.size()]);
List<String> roles = new ArrayList<>(Arrays.asList(rolesToDelete));
roles.remove(ROLE_EVERYONE);
rolesToDelete = new String[0];
// Clearing and re-initializing the set
existingRolesSet.clear();
Collections.addAll(existingRolesSet, existingRoles);
newRolesSet.removeAll(existingRolesSet);
// Now we have the roles to add
String[] rolesToAdd = newRolesSet.toArray(new String[newRolesSet.size()]);
userStoreManager.updateRoleListOfUser(userWrapper.getUsername(), rolesToDelete, rolesToAdd);
userStoreManager.setUserClaimValues(userWrapper.getUsername(), defaultUserClaims, null);
// Outputting debug message upon successful addition of user
if (log.isDebugEnabled()) {
log.debug("User by username: " + userWrapper.getUsername() + " was successfully updated.");
}
// returning response with success state
responsePayload.setStatusCode(HttpStatus.SC_CREATED);
responsePayload.setMessageFromServer("User by username: " + userWrapper.getUsername() +
" was successfully updated.");
return Response.status(Response.Status.CREATED).entity(responsePayload).build();
} else {
if (log.isDebugEnabled()) {
log.debug("User by username: " + userWrapper.getUsername() +
" doesn't exists. Therefore, request made to update user was refused.");
}
// returning response with bad request state
responsePayload.setStatusCode(HttpStatus.SC_CONFLICT);
responsePayload.
setMessageFromServer("User by username: " + userWrapper.getUsername() +
" doesn't exists. Therefore, request made to update user was refused.");
return Response.status(Response.Status.CONFLICT).entity(responsePayload).build();
}
} catch (UserStoreException | UnsupportedEncodingException | MDMAPIException e) {
String msg = "Exception in trying to update user by username: " + userWrapper.getUsername();
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Private method to be used by addUser() to
* generate an initial user password for a user.
* This will be the password used by a user for his initial login to the system.
*
* @return {string} Initial User Password
*/
private String generateInitialUserPassword() {
int passwordLength = 6;
//defining the pool of characters to be used for initial password generation
String lowerCaseCharset = "abcdefghijklmnopqrstuvwxyz";
String upperCaseCharset = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
String numericCharset = "0123456789";
Random randomGenerator = new Random();
String totalCharset = lowerCaseCharset + upperCaseCharset + numericCharset;
int totalCharsetLength = totalCharset.length();
StringBuilder initialUserPassword = new StringBuilder();
for (int i = 0; i < passwordLength; i++) {
initialUserPassword
.append(totalCharset.charAt(randomGenerator.nextInt(totalCharsetLength)));
}
if (log.isDebugEnabled()) {
log.debug("Initial user password is created for new user: " + initialUserPassword);
}
return initialUserPassword.toString();
}
/**
* Method to build default user claims.
*
* @param firstname First name of the user
* @param lastname Last name of the user
* @param emailAddress Email address of the user
* @return {Object} Default user claims to be provided
*/
private Map<String, String> buildDefaultUserClaims(String firstname, String lastname, String emailAddress) {
Map<String, String> defaultUserClaims = new HashMap<>();
defaultUserClaims.put(Constants.USER_CLAIM_FIRST_NAME, firstname);
defaultUserClaims.put(Constants.USER_CLAIM_LAST_NAME, lastname);
defaultUserClaims.put(Constants.USER_CLAIM_EMAIL_ADDRESS, emailAddress);
if (log.isDebugEnabled()) {
log.debug("Default claim map is created for new user: " + defaultUserClaims.toString());
}
return defaultUserClaims;
}
/**
* Method to remove user from emm-user-store.
*
* @param username Username of the user
* @return {Response} Status of the request wrapped inside Response object.
*/
@DELETE @DELETE
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response removeUser(@QueryParam("username") String username) { @ApiOperation(
ResponsePayload responsePayload = new ResponsePayload(); produces = MediaType.APPLICATION_JSON,
try { httpMethod = "DELETE",
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); value = "Deleting a User",
if (userStoreManager.isExistingUser(username)) { notes = "In a situation where an employee leaves the organization you will need to remove the"
// if user already exists, trying to remove user + " user details from WSO2 EMM. In such situations you can use this REST API "
userStoreManager.deleteUser(username); + "to remove a user",
// Outputting debug message upon successful removal of user response = ResponsePayload.class)
if (log.isDebugEnabled()) { @ApiResponses(value = {
log.debug("User by username: " + username + " was successfully removed."); @ApiResponse(code = 200, message = "User by username: 'username' was successfully removed"),
} @ApiResponse(code = 400, message = "User by username: 'username' does not exist for removal"),
// returning response with success state @ApiResponse(code = 500, message = "Exception in trying to remove user by username: 'username'")
responsePayload.setStatusCode(HttpStatus.SC_OK); })
responsePayload.setMessageFromServer( Response removeUser(@ApiParam(name = "username", value = "Provide the name of the user you wish to delete"
"User by username: " + username + " was successfully removed."); + " as the value for {username}", required = true)
return Response.status(Response.Status.OK).entity(responsePayload).build(); @QueryParam("username") String username);
} else {
// Outputting debug message upon trying to remove non-existing user
if (log.isDebugEnabled()) {
log.debug("User by username: " + username + " does not exist for removal.");
}
// returning response with bad request state
responsePayload.setStatusCode(HttpStatus.SC_BAD_REQUEST);
responsePayload.setMessageFromServer(
"User by username: " + username + " does not exist for removal.");
return Response.status(Response.Status.BAD_REQUEST).entity(responsePayload).build();
}
} catch (UserStoreException | MDMAPIException e) {
String msg = "Exception in trying to remove user by username: " + username;
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* get all the roles except for the internal/xxx and application/xxx
*
* @param userStoreManager User Store Manager associated with the currently logged in user
* @param username Username of the currently logged in user
* @return the list of filtered roles
*/
private List<String> getFilteredRoles(UserStoreManager userStoreManager, String username) {
String[] roleListOfUser = new String[0];
try {
roleListOfUser = userStoreManager.getRoleListOfUser(username);
} catch (UserStoreException e) {
e.printStackTrace();
}
List<String> filteredRoles = new ArrayList<>();
for (String role : roleListOfUser) {
if (!(role.startsWith("Internal/") || role.startsWith("Application/"))) {
filteredRoles.add(role);
}
}
return filteredRoles;
}
/**
* Get user's roles by username
*
* @param username Username of the user
* @return {Response} Status of the request wrapped inside Response object.
*/
@GET @GET
@Path("roles") @Path("roles")
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response getRoles(@QueryParam("username") String username) { @ApiOperation(
ResponsePayload responsePayload = new ResponsePayload(); produces = MediaType.APPLICATION_JSON,
try { httpMethod = "GET",
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); value = "Getting the Role Details of a User",
if (userStoreManager.isExistingUser(username)) { notes = "A user can be assigned to one or more role in WSO2 EMM. Using this REST API you are "
responsePayload.setResponseContent(Collections.singletonList(getFilteredRoles(userStoreManager, username))); + "able to get the role/roles a user is assigned to",
// Outputting debug message upon successful removal of user response = String.class,
if (log.isDebugEnabled()) { responseContainer = "List")
log.debug("User by username: " + username + " was successfully removed."); @ApiResponses(value = {
} @ApiResponse(code = 200, message = "User roles obtained for user : 'username'"),
// returning response with success state @ApiResponse(code = 400, message = "User by username: 'username' does not exist for role retrieval"),
responsePayload.setStatusCode(HttpStatus.SC_OK); @ApiResponse(code = 500, message = "Exception in trying to retrieve roles for user by username: 'username'")
responsePayload.setMessageFromServer( })
"User roles obtained for user " + username); Response getRoles(@ApiParam(name = "username", value = "Provide the user name of the user you wish to get"
return Response.status(Response.Status.OK).entity(responsePayload).build(); + " the role details", required = true) @QueryParam("username") String username);
} else {
// Outputting debug message upon trying to remove non-existing user
if (log.isDebugEnabled()) {
log.debug("User by username: " + username + " does not exist for role retrieval.");
}
// returning response with bad request state
responsePayload.setStatusCode(HttpStatus.SC_BAD_REQUEST);
responsePayload.setMessageFromServer(
"User by username: " + username + " does not exist for role retrieval.");
return Response.status(Response.Status.BAD_REQUEST).entity(responsePayload).build();
}
} catch (UserStoreException | MDMAPIException e) {
String msg = "Exception in trying to retrieve roles for user by username: " + username;
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Get the list of all users with all user-related info.
*
* @return A list of users
*/
@GET @GET
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response getAllUsers() { @ApiOperation(
if (log.isDebugEnabled()) { produces = MediaType.APPLICATION_JSON,
log.debug("Getting the list of users with all user-related information"); httpMethod = "GET",
} value = "Getting Details of Users",
List<UserWrapper> userList; notes = "If you wish to get the details of all the user registered with WSO2 EMM, you can do so "
try { + "using the REST API",
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); response = ResponsePayload.class)
String[] users = userStoreManager.listUsers("*", -1); @ApiResponses(value = {
userList = new ArrayList<>(users.length); @ApiResponse(code = 201, message = "All users were successfully retrieved"),
UserWrapper user; @ApiResponse(code = 500, message = "Error occurred while retrieving the list of users")
for (String username : users) { })
user = new UserWrapper(); Response getAllUsers();
user.setUsername(username);
user.setEmailAddress(getClaimValue(username, Constants.USER_CLAIM_EMAIL_ADDRESS));
user.setFirstname(getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME));
user.setLastname(getClaimValue(username, Constants.USER_CLAIM_LAST_NAME));
userList.add(user);
}
} catch (UserStoreException | MDMAPIException e) {
String msg = "Error occurred while retrieving the list of users";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
int count;
count = userList.size();
responsePayload.setMessageFromServer("All users were successfully retrieved. " +
"Obtained user count: " + count);
responsePayload.setResponseContent(userList);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get the list of all users with all user-related info.
*
* @return A list of users
*/
@GET @GET
@Path("{filter}") @Path("{filter}")
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response getMatchingUsers(@PathParam("filter") String filter) { Response getMatchingUsers(@PathParam("filter") String filter);
if (log.isDebugEnabled()) {
log.debug("Getting the list of users with all user-related information using the filter : " + filter);
}
List<UserWrapper> userList;
try {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
String[] users = userStoreManager.listUsers(filter + "*", -1);
userList = new ArrayList<>(users.length);
UserWrapper user;
for (String username : users) {
user = new UserWrapper();
user.setUsername(username);
user.setEmailAddress(getClaimValue(username, Constants.USER_CLAIM_EMAIL_ADDRESS));
user.setFirstname(getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME));
user.setLastname(getClaimValue(username, Constants.USER_CLAIM_LAST_NAME));
userList.add(user);
}
} catch (UserStoreException | MDMAPIException e) {
String msg = "Error occurred while retrieving the list of users using the filter : " + filter;
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
int count;
count = userList.size();
responsePayload.setMessageFromServer("All users were successfully retrieved. " +
"Obtained user count: " + count);
responsePayload.setResponseContent(userList);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get the list of user names in the system.
*
* @return A list of user names.
*/
@GET @GET
@Path("view-users") @Path("view-users")
public Response getAllUsersByUsername(@QueryParam("username") String userName) { @ApiOperation(
if (log.isDebugEnabled()) { produces = MediaType.APPLICATION_JSON,
log.debug("Getting the list of users by name"); httpMethod = "GET",
} value = "Getting User Details by Searching via the User Name",
List<UserWrapper> userList; notes = "You will have 100+ users registered with WSO2 EMM. If you wish to retrieve the user "
try { + "details of a specific user, and you only remember part of the user's username, "
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); + "you are able to retrieve the user details by giving a character or a few characters "
String[] users = userStoreManager.listUsers("*" + userName + "*", -1); + "in the username",
userList = new ArrayList<>(users.length); response = String.class,
UserWrapper user; responseContainer = "List")
for (String username : users) { @ApiResponses(value = {
user = new UserWrapper(); @ApiResponse(code = 200, message = "All users by username were successfully retrieved. Obtained"
user.setUsername(username); + " user count: 'count'"),
user.setEmailAddress(getClaimValue(username, Constants.USER_CLAIM_EMAIL_ADDRESS)); @ApiResponse(code = 500, message = "Error occurred while retrieving the list of users")
user.setFirstname(getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME)); })
user.setLastname(getClaimValue(username, Constants.USER_CLAIM_LAST_NAME)); Response getAllUsersByUsername(@ApiParam(name = "username", value = "Provide any user detail of the user"
userList.add(user); + " as the value for {username} to retrieve the user details, such "
} + "as email address, first name or last name", required = true)
} catch (UserStoreException | MDMAPIException e) { @QueryParam("username") String userName);
String msg = "Error occurred while retrieving the list of users";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
int count;
count = userList.size();
responsePayload.setMessageFromServer("All users by username were successfully retrieved. " +
"Obtained user count: " + count);
responsePayload.setResponseContent(userList);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get the list of user names in the system.
*
* @return A list of user names.
*/
@GET @GET
@Path("users-by-username") @Path("users-by-username")
public Response getAllUserNamesByUsername(@QueryParam("username") String userName) { @ApiOperation(
if (log.isDebugEnabled()) { produces = MediaType.APPLICATION_JSON,
log.debug("Getting the list of users by name"); httpMethod = "GET",
} value = "Searching for a User Name",
List<String> userList; notes = "You will have 100+ users registered with WSO2 EMM. Therefore if you are unsure of the "
try { + "user name of a user and need to retrieve the details of a specific user, you can "
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); + "search for that user by giving a character or a few characters in the username. "
String[] users = userStoreManager.listUsers("*" + userName + "*", -1); + "You will be given a list of users having the user name with the exact order of the "
userList = new ArrayList<>(users.length); + "characters you provided",
Collections.addAll(userList, users); response = String.class,
} catch (UserStoreException | MDMAPIException e) { responseContainer = "List")
String msg = "Error occurred while retrieving the list of users"; @ApiResponses(value = {
log.error(msg, e); @ApiResponse(code = 200, message = "All users by username were successfully retrieved. Obtained"
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); + " user count: 'count'"),
} @ApiResponse(code = 500, message = "Error occurred while retrieving the list of users")
ResponsePayload responsePayload = new ResponsePayload(); })
responsePayload.setStatusCode(HttpStatus.SC_OK); Response getAllUserNamesByUsername(@ApiParam(name = "username", value = "Provide a character or a few "
int count; + "character in the user name as the value for {username}",
count = userList.size(); required = true) @QueryParam("username") String userName);
responsePayload.setMessageFromServer("All users by username were successfully retrieved. " +
"Obtained user count: " + count);
responsePayload.setResponseContent(userList);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Gets a claim-value from user-store.
*
* @param username Username of the user
* @param claimUri required ClaimUri
* @return claim value
*/
private String getClaimValue(String username, String claimUri) throws MDMAPIException {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
try {
return userStoreManager.getUserClaimValue(username, claimUri, null);
} catch (UserStoreException e) {
throw new MDMAPIException("Error occurred while retrieving value assigned to the claim '" +
claimUri + "'", e);
}
}
/**
* Method used to send an invitation email to a new user to enroll a device.
*
* @param username Username of the user
*/
private void inviteNewlyAddedUserToEnrollDevice(String username, String password) throws MDMAPIException {
if (log.isDebugEnabled()) {
log.debug("Sending invitation mail to user by username: " + username);
}
String tenantDomain = CarbonContext.getThreadLocalCarbonContext().getTenantDomain();
if (MultitenantConstants.SUPER_TENANT_DOMAIN_NAME.equalsIgnoreCase(tenantDomain)) {
tenantDomain = "";
}
if (!username.contains("/")) {
username = "/" + username;
}
String[] usernameBits = username.split("/");
DeviceManagementProviderService deviceManagementProviderService = DeviceMgtAPIUtils.getDeviceManagementService();
Properties props = new Properties();
props.setProperty("username", usernameBits[1]);
props.setProperty("domain-name", tenantDomain);
props.setProperty("first-name", getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME));
props.setProperty("password", password);
String recipient = getClaimValue(username, Constants.USER_CLAIM_EMAIL_ADDRESS);
EmailMetaInfo metaInfo = new EmailMetaInfo(recipient, props);
try {
deviceManagementProviderService.sendRegistrationEmail(metaInfo);
} catch (DeviceManagementException e) {
String msg = "Error occurred while sending registration email to user '" + username + "'";
log.error(msg, e);
throw new MDMAPIException(msg, e);
}
}
/**
* Method used to send an invitation email to a existing user to enroll a device.
*
* @param usernames Username list of the users to be invited
*/
@POST @POST
@Path("email-invitation") @Path("email-invitation")
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response inviteExistingUsersToEnrollDevice(List<String> usernames) { @ApiOperation(
if (log.isDebugEnabled()) { produces = MediaType.APPLICATION_JSON,
log.debug("Sending enrollment invitation mail to existing user."); httpMethod = "POST",
} value = "Sending Enrollment Invitations to Users",
DeviceManagementProviderService deviceManagementProviderService = DeviceMgtAPIUtils.getDeviceManagementService(); notes = "Send the users a mail inviting them to download the EMM mobile application on their "
try { + "devices using this REST API")
for (String username : usernames) { @ApiResponses(value = {
String recipient = getClaimValue(username, Constants.USER_CLAIM_EMAIL_ADDRESS); @ApiResponse(code = 200, message = "Email invitation was successfully sent to user"),
@ApiResponse(code = 500, message = "Error occurred while retrieving the list of users")
})
Response inviteExistingUsersToEnrollDevice(@ApiParam(name = "usernames", value = "List of the users to be"
+ " invited as the <JSON_PAYLOAD>", required = true)
List<String> usernames);
Properties props = new Properties();
props.setProperty("first-name", getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME));
props.setProperty("username", username);
EmailMetaInfo metaInfo = new EmailMetaInfo(recipient, props);
deviceManagementProviderService.sendEnrolmentInvitation(metaInfo);
}
} catch (DeviceManagementException | MDMAPIException e) {
String msg = "Error occurred while inviting user to enrol their device";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Email invitation was successfully sent to user.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get a list of devices based on the username.
*
* @param username Username of the device owner
* @return A list of devices
*/
@GET @GET
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
@Path("devices") @Path("devices")
public Response getAllDeviceOfUser(@QueryParam("username") String username, @QueryParam("start") int startIdx, @ApiOperation(
@QueryParam("length") int length) { produces = MediaType.APPLICATION_JSON,
DeviceManagementProviderService dmService; httpMethod = "GET",
try { value = "Getting Device Details of a User",
dmService = DeviceMgtAPIUtils.getDeviceManagementService(); notes = "If you wish to get the details of the devices enrolled by a specific user, you can do "
if (length > 0) { + "so using this REST API",
PaginationRequest request = new PaginationRequest(startIdx, length); response = org.wso2.carbon.device.mgt.common.Device.class,
request.setOwner(username); responseContainer = "List")
return Response.status(Response.Status.OK).entity(dmService.getDevicesOfUser(request)).build(); @ApiResponses(value = {
} @ApiResponse(code = 200, message = "OK"),
return Response.status(Response.Status.OK).entity(dmService.getDevicesOfUser(username)).build(); @ApiResponse(code = 500, message = "Device management error")
} catch (DeviceManagementException e) { })
String msg = "Device management error"; Response getAllDeviceOfUser(@ApiParam(name = "username", value = "Provide the name of the user you wish "
log.error(msg, e); + "to get the details", required = true) @QueryParam("username")
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build(); String username,
} @ApiParam(name = "start", value = "Provide the starting pagination index",
} required = true) @QueryParam("start") int startIdx,
@ApiParam(name = "length", value = "Provide how many device details you "
+ "require from the starting pagination index", required = true)
@QueryParam("length") int length);
/**
* This method is used to retrieve the user count of the system.
*
* @return returns the count.
* @
*/
@GET @GET
@Path("count") @Path("count")
public Response getUserCount() { @ApiOperation(
try { httpMethod = "GET",
String[] users = DeviceMgtAPIUtils.getUserStoreManager().listUsers("*", -1); value = "Getting the User Count",
Integer count = 0; notes = "Get the number of users in WSO2 EMM",
if (users != null) { response = Integer.class)
count = users.length; @ApiResponses(value = {
} @ApiResponse(code = 200, message = "OK"),
return Response.status(Response.Status.OK).entity(count).build(); @ApiResponse(code = 500, message = "Error occurred while retrieving the list of users that exist"
} catch (UserStoreException | MDMAPIException e) { + " within the current tenant")
String msg = })
"Error occurred while retrieving the list of users that exist within the current tenant"; Response getUserCount();
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* API is used to update roles of a user
*
* @param username
* @param userList
* @return
* @
*/
@PUT @PUT
@Path("{roleName}/users") @Path("{roleName}/users")
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response updateRoles(@PathParam("username") String username, List<String> userList) { Response updateRoles(@PathParam("username") String username, List<String> userList);
try {
final UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
if (log.isDebugEnabled()) {
log.debug("Updating the roles of a user");
}
SetReferenceTransformer<String> transformer = new SetReferenceTransformer<>();
transformer.transform(Arrays.asList(userStoreManager.getRoleListOfUser(username)),
userList);
final String[] rolesToAdd = transformer.getObjectsToAdd().toArray(new String[transformer.getObjectsToAdd().size()]);
final String[] rolesToDelete = transformer.getObjectsToRemove().toArray(new String[transformer.getObjectsToRemove().size()]);
userStoreManager.updateRoleListOfUser(username, rolesToDelete, rolesToAdd);
} catch (UserStoreException | MDMAPIException e) {
String msg = "Error occurred while saving the roles for user: " + username;
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).build();
}
/**
* Method to change the user password.
*
* @param credentials Wrapper object representing user credentials.
* @return {Response} Status of the request wrapped inside Response object.
* @
*/
@POST @POST
@Path("change-password") @Path("change-password")
@Consumes({MediaType.APPLICATION_JSON}) @Consumes({MediaType.APPLICATION_JSON})
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response resetPassword(UserCredentialWrapper credentials) { @ApiOperation(
return CredentialManagementResponseBuilder.buildChangePasswordResponse(credentials); consumes = MediaType.APPLICATION_JSON,
} produces = MediaType.APPLICATION_JSON,
httpMethod = "POST",
value = "Changing the User Password",
notes = "A user is able to change the password to secure their EMM profile via this REST API",
response = UserCredentialWrapper.class)
@ApiResponses(value = {
@ApiResponse(code = 200, message = "UserImpl password by username: 'Username' was "
+ "successfully changed"),
@ApiResponse(code = 400, message = "Old password does not match"),
@ApiResponse(code = 400, message = "Could not change the password of the user: 'Username'. The"
+ " Character Encoding is not supported"),
@ApiResponse(code = 500, message = "Internal Server Error")
})
Response resetPassword(@ApiParam(name = "credentials", value = "Include the required properties to change"
+ " the user password as <JSON_PAYLOAD> value", required = true)
UserCredentialWrapper credentials);
/**
* Method to change the user password.
*
* @param credentials Wrapper object representing user credentials.
* @return {Response} Status of the request wrapped inside Response object.
* @
*/
@POST @POST
@Path("reset-password") @Path("reset-password")
@Consumes({MediaType.APPLICATION_JSON}) @Consumes({MediaType.APPLICATION_JSON})
@Produces({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON})
public Response resetPasswordByAdmin(UserCredentialWrapper credentials) { @ApiOperation(
return CredentialManagementResponseBuilder.buildResetPasswordResponse(credentials); consumes = MediaType.APPLICATION_JSON,
} produces = MediaType.APPLICATION_JSON,
httpMethod = "POST",
} value = "Resetting the User Password",
notes = "In a situation where you need to block a user from accessing their EMM profile, "
+ "the EMM administrator is able to reset the password. This will change the user's "
+ "password and the user will not be able to able to login to the account as he/she is "
+ "not aware of the new password.",
response = UserCredentialWrapper.class)
@ApiResponses(value = {
@ApiResponse(code = 200, message = "UserImpl password by username: 'Username' was "
+ "successfully changed"),
@ApiResponse(code = 400, message = "Old password does not match"),
@ApiResponse(code = 400, message = "Could not change the password of the user: 'Username'. The"
+ " Character Encoding is not supported"),
@ApiResponse(code = 500, message = "Internal Server Error")
})
Response resetPasswordByAdmin(@ApiParam(name = "credentials", value = "Include the required properties "
+ "to change a user password as <JSON_PAYLOAD> value",
required = true) UserCredentialWrapper credentials);
}

@ -0,0 +1,36 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.ws.rs.Consumes;
import javax.ws.rs.Produces;
/**
* Authentication related REST-API implementation.
*/
@Produces({ "application/json", "application/xml" })
@Consumes({ "application/json", "application/xml" })
public class AuthenticationImpl {
private static Log log = LogFactory.getLog(AuthenticationImpl.class);
}

@ -0,0 +1,195 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.certificate.mgt.core.dao.CertificateManagementDAOException;
import org.wso2.carbon.certificate.mgt.core.dto.CertificateResponse;
import org.wso2.carbon.certificate.mgt.core.exception.KeystoreException;
import org.wso2.carbon.certificate.mgt.core.service.CertificateManagementService;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.jaxrs.api.Certificate;
import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException;
import org.wso2.carbon.device.mgt.common.PaginationRequest;
import org.wso2.carbon.device.mgt.common.PaginationResult;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.beans.EnrollmentCertificate;
import org.wso2.carbon.device.mgt.jaxrs.exception.Message;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.HeaderParam;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.ArrayList;
import java.util.List;
/**
* All the certificate related tasks such as saving certificates, can be done through this endpoint.
*/
@SuppressWarnings("NonJaxWsWebServices")
@Produces({"application/json", "application/xml"})
@Consumes({ "application/json", "application/xml" })
public class CertificateImpl implements Certificate {
private static Log log = LogFactory.getLog(OperationImpl.class);
/**
* Save a list of certificates and relevant information in the database.
*
* @param enrollmentCertificates List of all the certificates which includes the tenant id, certificate as
* a pem and a serial number.
* @return Status of the data persist operation.
*/
@POST
@Path("saveCertificate")
public Response saveCertificate(@HeaderParam("Accept") String acceptHeader,
EnrollmentCertificate[] enrollmentCertificates) {
MediaType responseMediaType = DeviceMgtAPIUtils.getResponseMediaType(acceptHeader);
CertificateManagementService certificateService;
List<org.wso2.carbon.certificate.mgt.core.bean.Certificate> certificates = new ArrayList<>();
org.wso2.carbon.certificate.mgt.core.bean.Certificate certificate;
certificateService = DeviceMgtAPIUtils.getCertificateManagementService();
try {
for (EnrollmentCertificate enrollmentCertificate : enrollmentCertificates) {
certificate = new org.wso2.carbon.certificate.mgt.core.bean.Certificate();
certificate.setTenantId(PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId());
certificate.setSerial(enrollmentCertificate.getSerial());
certificate.setCertificate(certificateService.pemToX509Certificate(enrollmentCertificate.getPem()));
certificates.add(certificate);
}
certificateService.saveCertificate(certificates);
return Response.status(Response.Status.CREATED).entity("Added successfully.").
type(responseMediaType).build();
} catch (KeystoreException e) {
String msg = "Error occurred while converting PEM file to X509Certificate.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).type(responseMediaType).build();
}
}
/**
* Get a certificate when the serial number is given.
*
* @param serialNumber serial of the certificate needed.
* @return certificate response.
*/
@GET
@Path("{serialNumber}")
public Response getCertificate(@HeaderParam("Accept") String acceptHeader,
@PathParam("serialNumber") String serialNumber) {
MediaType responseMediaType = DeviceMgtAPIUtils.getResponseMediaType(acceptHeader);
Message message = new Message();
if (serialNumber == null || serialNumber.isEmpty()) {
message.setErrorMessage("Invalid serial number");
message.setDiscription("Serial number is missing or invalid.");
return Response.status(Response.Status.BAD_REQUEST).entity(message).type(responseMediaType).build();
}
CertificateManagementService certificateService = DeviceMgtAPIUtils.getCertificateManagementService();
CertificateResponse certificateResponse;
try {
certificateResponse = certificateService.getCertificateBySerial(serialNumber);
if(certificateResponse != null) {
certificateResponse.setCertificate(null); //avoid sending byte array in response.
}
return Response.status(Response.Status.OK).entity(certificateResponse).type(responseMediaType).build();
} catch (KeystoreException e) {
String msg = "Error occurred while converting PEM file to X509Certificate";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).type(responseMediaType).build();
}
}
/**
* Get all certificates in a paginated manner.
*
* @param startIndex index of the first record to be fetched
* @param length number of records to be fetched starting from the start index.
* @return paginated result of certificate.
* @throws MDMAPIException
*/
@GET
@Path("paginate")
public Response getAllCertificates(@HeaderParam("Accept") String acceptHeader,
@QueryParam("start") int startIndex,
@QueryParam("length") int length)
throws MDMAPIException {
MediaType responseMediaType = DeviceMgtAPIUtils.getResponseMediaType(acceptHeader);
Message message = new Message();
if (startIndex < 0) {
message.setErrorMessage("Invalid start index.");
message.setDiscription("Start index cannot be less that 0.");
return Response.status(Response.Status.BAD_REQUEST).entity(message).type(responseMediaType).build();
} else if (length <= 0) {
message.setErrorMessage("Invalid length value.");
message.setDiscription("Length should be a positive integer.");
return Response.status(Response.Status.BAD_REQUEST).entity(message).type(responseMediaType).build();
}
CertificateManagementService certificateService = DeviceMgtAPIUtils.getCertificateManagementService();
PaginationRequest paginationRequest = new PaginationRequest(startIndex, length);
try {
PaginationResult certificates = certificateService.getAllCertificates(paginationRequest);
return Response.status(Response.Status.OK).entity(certificates).type(responseMediaType).build();
} catch (CertificateManagementDAOException e) {
String msg = "Error occurred while fetching all certificates.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).type(responseMediaType).build();
}
}
@DELETE
@Path("{serialNumber}")
public Response removeCertificate(@HeaderParam("Accept") String acceptHeader,
@PathParam("serialNumber") String serialNumber) throws MDMAPIException {
MediaType responseMediaType = DeviceMgtAPIUtils.getResponseMediaType(acceptHeader);
Message message = new Message();
if (serialNumber == null || serialNumber.isEmpty()) {
message.setErrorMessage("Invalid serial number");
message.setDiscription("Serial number is missing or invalid.");
return Response.status(Response.Status.BAD_REQUEST).entity(message).type(responseMediaType).build();
}
CertificateManagementService certificateService = DeviceMgtAPIUtils.getCertificateManagementService();
boolean deleted;
try {
deleted = certificateService.removeCertificate(serialNumber);
if(deleted){
return Response.status(Response.Status.OK).entity(deleted).type(responseMediaType).build();
} else {
return Response.status(Response.Status.GONE).entity(deleted).type(responseMediaType).build();
}
} catch (CertificateManagementDAOException e) {
String msg = "Error occurred while converting PEM file to X509Certificate";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).type(responseMediaType).build();
}
}
}

@ -0,0 +1,113 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.configuration.mgt.ConfigurationEntry;
import org.wso2.carbon.device.mgt.common.configuration.mgt.ConfigurationManagementException;
import org.wso2.carbon.device.mgt.common.configuration.mgt.TenantConfiguration;
import org.wso2.carbon.device.mgt.jaxrs.api.Configuration;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.api.util.MDMAppConstants;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.policy.mgt.core.util.PolicyManagerUtil;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Response;
import java.util.ArrayList;
import java.util.List;
/**
* General Tenant Configuration REST-API implementation.
* All end points support JSON, XMl with content negotiation.
*/
@SuppressWarnings("NonJaxWsWebServices")
@Produces({"application/json", "application/xml"})
@Consumes({ "application/json", "application/xml" })
public class ConfigurationImpl implements Configuration{
private static Log log = LogFactory.getLog(ConfigurationImpl.class);
@POST
public Response saveTenantConfiguration(TenantConfiguration configuration) {
ResponsePayload responseMsg = new ResponsePayload();
try {
DeviceMgtAPIUtils.getTenantConfigurationManagementService().saveConfiguration(configuration,
MDMAppConstants.RegistryConstants.GENERAL_CONFIG_RESOURCE_PATH);
//Schedule the task service
DeviceMgtAPIUtils.scheduleTaskService(DeviceMgtAPIUtils.getNotifierFrequency(configuration));
responseMsg.setMessageFromServer("Tenant configuration saved successfully.");
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (ConfigurationManagementException e) {
String msg = "Error occurred while saving the tenant configuration.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@GET
public Response getConfiguration() {
String msg;
try {
TenantConfiguration tenantConfiguration = DeviceMgtAPIUtils.getTenantConfigurationManagementService().
getConfiguration(MDMAppConstants.RegistryConstants.GENERAL_CONFIG_RESOURCE_PATH);
ConfigurationEntry configurationEntry = new ConfigurationEntry();
configurationEntry.setContentType("text");
configurationEntry.setName("notifierFrequency");
configurationEntry.setValue(PolicyManagerUtil.getMonitoringFequency());
List<ConfigurationEntry> configList = tenantConfiguration.getConfiguration();
if (configList == null) {
configList = new ArrayList<>();
}
configList.add(configurationEntry);
tenantConfiguration.setConfiguration(configList);
return Response.status(Response.Status.OK).entity(tenantConfiguration).build();
} catch (ConfigurationManagementException e) {
msg = "Error occurred while retrieving the tenant configuration.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@PUT
public Response updateConfiguration(TenantConfiguration configuration) {
ResponsePayload responseMsg = new ResponsePayload();
try {
DeviceMgtAPIUtils.getTenantConfigurationManagementService().saveConfiguration(configuration,
MDMAppConstants.RegistryConstants.GENERAL_CONFIG_RESOURCE_PATH);
//Schedule the task service
DeviceMgtAPIUtils.scheduleTaskService(DeviceMgtAPIUtils.getNotifierFrequency(configuration));
responseMsg.setMessageFromServer("Tenant configuration updated successfully.");
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (ConfigurationManagementException e) {
String msg = "Error occurred while updating the tenant configuration.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
}

@ -0,0 +1,285 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.jaxrs.api.Device;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
import org.wso2.carbon.device.mgt.common.PaginationRequest;
import org.wso2.carbon.device.mgt.core.dto.DeviceType;
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.List;
/**
* Device related operations
*/
@SuppressWarnings("NonJaxWsWebServices")
public class DeviceImpl implements Device{
private static Log log = LogFactory.getLog(DeviceImpl.class);
/**
* Get all devices. We have to use accept all the necessary query parameters sent by datatable.
* Hence had to put lot of query params here.
*
* @return Device List
*/
@GET
public Response getAllDevices(@QueryParam("type") String type, @QueryParam("user") String user,
@QueryParam("role") String role, @QueryParam("status") EnrolmentInfo.Status status,
@QueryParam("start") int startIdx, @QueryParam("length") int length,
@QueryParam("device-name") String deviceName,
@QueryParam("ownership") EnrolmentInfo.OwnerShip ownership) {
try {
DeviceManagementProviderService service = DeviceMgtAPIUtils.getDeviceManagementService();
//Length > 0 means this is a pagination request.
if (length > 0) {
PaginationRequest paginationRequest = new PaginationRequest(startIdx, length);
paginationRequest.setDeviceName(deviceName);
paginationRequest.setOwner(user);
if (ownership != null) {
paginationRequest.setOwnership(ownership.toString());
}
if (status != null) {
paginationRequest.setStatus(status.toString());
}
paginationRequest.setDeviceType(type);
return Response.status(Response.Status.OK).entity(service.getAllDevices(paginationRequest)).build();
}
List<org.wso2.carbon.device.mgt.common.Device> allDevices;
if ((type != null) && !type.isEmpty()) {
allDevices = service.getAllDevices(type);
} else if ((user != null) && !user.isEmpty()) {
allDevices = service.getDevicesOfUser(user);
} else if ((role != null) && !role.isEmpty()) {
allDevices = service.getAllDevicesOfRole(role);
} else if (status != null) {
allDevices = service.getDevicesByStatus(status);
} else if (deviceName != null) {
allDevices = service.getDevicesByName(deviceName);
} else {
allDevices = service.getAllDevices();
}
return Response.status(Response.Status.OK).entity(allDevices).build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the device list.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Fetch device details for a given device type and device Id.
*
* @return Device wrapped inside Response
*/
@GET
@Path("view")
@Produces({MediaType.APPLICATION_JSON})
public Response getDevice(@QueryParam("type") String type,
@QueryParam("id") String id) {
DeviceIdentifier deviceIdentifier = DeviceMgtAPIUtils.instantiateDeviceIdentifier(type, id);
DeviceManagementProviderService deviceManagementProviderService = DeviceMgtAPIUtils.getDeviceManagementService();
org.wso2.carbon.device.mgt.common.Device device;
try {
device = deviceManagementProviderService.getDevice(deviceIdentifier);
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the device information.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
if (device == null) {
responsePayload.setStatusCode(HttpStatus.SC_NOT_FOUND);
responsePayload.setMessageFromServer("Requested device by type: " +
type + " and id: " + id + " does not exist.");
return Response.status(Response.Status.NOT_FOUND).entity(responsePayload).build();
} else {
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Sending Requested device by type: " + type + " and id: " + id + ".");
responsePayload.setResponseContent(device);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
}
/**
* Fetch device details of a given user.
*
* @param user User Name
* @return Device
*/
@GET
@Path("user/{user}")
public Response getDevice(@PathParam("user") String user) {
List<org.wso2.carbon.device.mgt.common.Device> devices;
try {
devices = DeviceMgtAPIUtils.getDeviceManagementService().getDevicesOfUser(user);
if (devices == null) {
return Response.status(Response.Status.NOT_FOUND).build();
}
return Response.status(Response.Status.OK).entity(devices).build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the devices list of given user.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Fetch device count of a given user.
*
* @param user User Name
* @return Device
*/
@GET
@Path("user/{user}/count")
public Response getDeviceCount(@PathParam("user") String user) {
try {
Integer count = DeviceMgtAPIUtils.getDeviceManagementService().getDeviceCount(user);
return Response.status(Response.Status.OK).entity(count).build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the devices list of given user.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Get current device count
*
* @return device count
*/
@GET
@Path("count")
public Response getDeviceCount() {
try {
Integer count = DeviceMgtAPIUtils.getDeviceManagementService().getDeviceCount();
return Response.status(Response.Status.OK).entity(count).build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the device count.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Get the list of devices that matches with the given name.
*
* @param deviceName Device name
* @param tenantDomain Callee tenant domain
* @return list of devices.
*/
@GET
@Path("name/{name}/{tenantDomain}")
public Response getDevicesByName(@PathParam("name") String deviceName,
@PathParam("tenantDomain") String tenantDomain) {
List<org.wso2.carbon.device.mgt.common.Device> devices;
try {
devices = DeviceMgtAPIUtils.getDeviceManagementService().getDevicesByName(deviceName);
return Response.status(Response.Status.OK).entity(devices).build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the devices list of device name.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Get the list of available device types.
*
* @return list of device types.
*/
@GET
@Path("types")
public Response getDeviceTypes() {
List<DeviceType> deviceTypes;
try {
deviceTypes = DeviceMgtAPIUtils.getDeviceManagementService().getAvailableDeviceTypes();
return Response.status(Response.Status.OK).entity(deviceTypes).build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the list of device types.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Update device.
*
* @return update status.
*/
@PUT
@Path("type/{type}/id/{deviceId}")
public Response updateDevice(@PathParam("type") String deviceType, @PathParam("deviceId") String deviceId,
org.wso2.carbon.device.mgt.common.Device updatedDevice) {
try {
DeviceManagementProviderService deviceManagementService = DeviceMgtAPIUtils.getDeviceManagementService();
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
deviceIdentifier.setType(deviceType);
deviceIdentifier.setId(deviceId);
org.wso2.carbon.device.mgt.common.Device device = deviceManagementService.getDevice(deviceIdentifier);
device.setName(updatedDevice.getName());
device.setDescription(updatedDevice.getDescription());
Boolean response = deviceManagementService.modifyEnrollment(device);
return Response.status(Response.Status.OK).entity(response).build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the list of device types.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* disenroll device.
*
* @return disenrollment status.
*/
@DELETE
@Path("type/{type}/id/{deviceId}")
public Response disenrollDevice(@PathParam("type") String deviceType, @PathParam("deviceId") String deviceId) {
try {
DeviceManagementProviderService deviceManagementService = DeviceMgtAPIUtils.getDeviceManagementService();
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
deviceIdentifier.setType(deviceType);
deviceIdentifier.setId(deviceId);
Boolean response = deviceManagementService.disenrollDevice(deviceIdentifier);
return Response.status(Response.Status.OK).entity(response).build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while fetching the list of device types.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
}

@ -0,0 +1,81 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.device.details.DeviceInfo;
import org.wso2.carbon.device.mgt.common.device.details.DeviceLocation;
import org.wso2.carbon.device.mgt.core.device.details.mgt.DeviceDetailsMgtException;
import org.wso2.carbon.device.mgt.core.device.details.mgt.DeviceInformationManager;
import org.wso2.carbon.device.mgt.jaxrs.api.DeviceInformation;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.core.Response;
@SuppressWarnings("NonJaxWsWebServices")
public class DeviceInformationImpl implements DeviceInformation {
private static Log log = LogFactory.getLog(DeviceInformationImpl.class);
@GET
@Path("{type}/{id}")
public Response getDeviceInfo(@PathParam("type") String type, @PathParam("id") String id) {
DeviceInformationManager informationManager;
DeviceInfo deviceInfo;
try {
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
deviceIdentifier.setId(id);
deviceIdentifier.setType(type);
informationManager = DeviceMgtAPIUtils.getDeviceInformationManagerService();
deviceInfo = informationManager.getDeviceInfo(deviceIdentifier);
} catch (DeviceDetailsMgtException e) {
String msg = "Error occurred while getting the device information.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).entity(deviceInfo).build();
}
@GET
@Path("location/{type}/{id}")
public Response getDeviceLocation(@PathParam("type") String type, @PathParam("id") String id) {
DeviceInformationManager informationManager;
DeviceLocation deviceLocation;
try {
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
deviceIdentifier.setId(id);
deviceIdentifier.setType(type);
informationManager = DeviceMgtAPIUtils.getDeviceInformationManagerService();
deviceLocation = informationManager.getDeviceLocation(deviceIdentifier);
} catch (DeviceDetailsMgtException e) {
String msg = "Error occurred while getting the device location.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).entity(deviceLocation).build();
}
}

@ -0,0 +1,110 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.jaxrs.api.DeviceNotification;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.common.notification.mgt.Notification;
import org.wso2.carbon.device.mgt.common.notification.mgt.NotificationManagementException;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Response;
import java.util.List;
/**
* DeviceNotification management REST-API implementation.
* All end points support JSON, XMl with content negotiation.
*/
@SuppressWarnings("NonJaxWsWebServices")
@Produces({"application/json", "application/xml"})
@Consumes({ "application/json", "application/xml" })
public class DeviceNotificationImpl implements DeviceNotification{
private static Log log = LogFactory.getLog(ConfigurationImpl.class);
@GET
public Response getNotifications() {
String msg;
try {
List<Notification> notifications = DeviceMgtAPIUtils.getNotificationManagementService().getAllNotifications();
return Response.status(Response.Status.OK).entity(notifications).build();
} catch (NotificationManagementException e) {
msg = "Error occurred while retrieving the notification list.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@GET
@Path("{status}")
public Response getNotificationsByStatus(@PathParam("status") Notification.Status status) {
String msg;
try {
List<Notification> notifications = DeviceMgtAPIUtils.getNotificationManagementService().getNotificationsByStatus(status);
return Response.status(Response.Status.OK).entity(notifications).build();
} catch (NotificationManagementException e) {
msg = "Error occurred while retrieving the notification list.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@PUT
@Path("{id}/{status}")
public Response updateNotificationStatus(@PathParam("id") int id,
@PathParam("status") Notification.Status status) {
ResponsePayload responseMsg = new ResponsePayload();
try {
DeviceMgtAPIUtils.getNotificationManagementService().updateNotificationStatus(id, status);
responseMsg.setMessageFromServer("Notification status updated successfully.");
responseMsg.setStatusCode(HttpStatus.SC_ACCEPTED);
return Response.status(Response.Status.ACCEPTED).entity(responseMsg).build();
} catch (NotificationManagementException e) {
String msg = "Error occurred while updating notification status.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@POST
public Response addNotification(Notification notification) {
ResponsePayload responseMsg = new ResponsePayload();
try {
DeviceMgtAPIUtils.getNotificationManagementService().addNotification(notification);
responseMsg.setMessageFromServer("Notification has added successfully.");
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (NotificationManagementException e) {
String msg = "Error occurred while updating notification status.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
}

@ -0,0 +1,56 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.device.details.DeviceWrapper;
import org.wso2.carbon.device.mgt.common.search.SearchContext;
import org.wso2.carbon.device.mgt.core.search.mgt.SearchManagerService;
import org.wso2.carbon.device.mgt.core.search.mgt.SearchMgtException;
import org.wso2.carbon.device.mgt.jaxrs.api.DeviceSearch;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import javax.ws.rs.GET;
import javax.ws.rs.core.Response;
import java.util.List;
@SuppressWarnings("NonJaxWsWebServices")
public class DeviceSearchImpl implements DeviceSearch {
private static Log log = LogFactory.getLog(DeviceSearchImpl.class);
@GET
public Response getDeviceInfo(SearchContext searchContext) {
SearchManagerService searchManagerService;
List<DeviceWrapper> devices;
try {
searchManagerService = DeviceMgtAPIUtils.getSearchManagerService();
devices = searchManagerService.search(searchContext);
} catch (SearchMgtException e) {
String msg = "Error occurred while searching the device information.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).entity(devices).build();
}
}

@ -0,0 +1,66 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.jaxrs.api.Feature;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Response;
import java.util.List;
/**
* Features
*/
@SuppressWarnings("NonJaxWsWebServices")
@Produces({"application/json", "application/xml"})
@Consumes({"application/json", "application/xml"})
public class FeatureImpl implements Feature{
private static Log log = LogFactory.getLog(FeatureImpl.class);
/**
* Get all features for Mobile Device Type
*
* @return Feature
*/
@GET
@Path("/{type}")
public Response getFeatures(@PathParam("type") String type) {
List<org.wso2.carbon.device.mgt.common.Feature> features;
DeviceManagementProviderService dmService;
try {
dmService = DeviceMgtAPIUtils.getDeviceManagementService();
features = dmService.getFeatureManager(type).getFeatures();
} catch (DeviceManagementException e) {
String msg = "Error occurred while retrieving the list of features";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).entity(features).build();
}
}

@ -0,0 +1,533 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.PaginationResult;
import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroup;
import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroupConstants;
import org.wso2.carbon.device.mgt.common.group.mgt.GroupAlreadyEixistException;
import org.wso2.carbon.device.mgt.common.group.mgt.GroupManagementException;
import org.wso2.carbon.device.mgt.common.group.mgt.GroupUser;
import org.wso2.carbon.device.mgt.core.service.GroupManagementProviderService;
import org.wso2.carbon.device.mgt.jaxrs.api.Group;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.user.core.multiplecredentials.UserDoesNotExistException;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.FormParam;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Response;
import java.util.Date;
import java.util.List;
@SuppressWarnings("NonJaxWsWebServices")
public class GroupImpl implements Group {
private static Log log = LogFactory.getLog(GroupImpl.class);
@Override
@POST
@Consumes("application/json")
public Response createGroup(DeviceGroup group) {
String owner = PrivilegedCarbonContext.getThreadLocalCarbonContext().getUsername();
if (group == null) {
return Response.status(Response.Status.BAD_REQUEST).build();
}
group.setOwner(owner);
group.setDateOfCreation(new Date().getTime());
group.setDateOfLastUpdate(new Date().getTime());
try {
GroupManagementProviderService groupManagementService = DeviceMgtAPIUtils.getGroupManagementProviderService();
groupManagementService.createGroup(group, DeviceGroupConstants.Roles.DEFAULT_ADMIN_ROLE, DeviceGroupConstants.Permissions.DEFAULT_ADMIN_PERMISSIONS);
groupManagementService.addGroupSharingRole(owner, group.getName(), owner,
DeviceGroupConstants.Roles.DEFAULT_OPERATOR_ROLE,
DeviceGroupConstants.Permissions.DEFAULT_OPERATOR_PERMISSIONS);
groupManagementService.addGroupSharingRole(owner, group.getName(), owner, DeviceGroupConstants.Roles.DEFAULT_STATS_MONITOR_ROLE,
DeviceGroupConstants.Permissions.DEFAULT_STATS_MONITOR_PERMISSIONS);
groupManagementService.addGroupSharingRole(owner, group.getName(), owner, DeviceGroupConstants.Roles.DEFAULT_VIEW_POLICIES,
DeviceGroupConstants.Permissions.DEFAULT_VIEW_POLICIES_PERMISSIONS);
groupManagementService.addGroupSharingRole(owner, group.getName(), owner, DeviceGroupConstants.Roles.DEFAULT_MANAGE_POLICIES,
DeviceGroupConstants.Permissions.DEFAULT_MANAGE_POLICIES_PERMISSIONS);
groupManagementService.addGroupSharingRole(owner, group.getName(), owner, DeviceGroupConstants.Roles.DEFAULT_VIEW_EVENTS,
DeviceGroupConstants.Permissions.DEFAULT_VIEW_EVENTS_PERMISSIONS);
return Response.status(Response.Status.CREATED).build();
} catch (GroupAlreadyEixistException e) {
return Response.status(Response.Status.CONFLICT).entity(e.getMessage()).build();
} catch (GroupManagementException e) {
log.error(e.getErrorMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@Path("/owner/{owner}/name/{groupName}")
@PUT
@Consumes("application/json")
@Produces("application/json")
public Response updateGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
DeviceGroup deviceGroup) {
try {
DeviceMgtAPIUtils.getGroupManagementProviderService().updateGroup(deviceGroup, groupName, owner);
return Response.status(Response.Status.OK).build();
} catch (GroupManagementException e) {
log.error(e.getErrorMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@Path("/owner/{owner}/name/{groupName}")
@DELETE
public Response deleteGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner) {
try {
DeviceMgtAPIUtils.getGroupManagementProviderService().deleteGroup(groupName, owner);
return Response.status(Response.Status.OK).build();
} catch (GroupManagementException e) {
log.error(e.getMessage());
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@GET
@Produces("application/json")
public Response getGroups(@QueryParam("start") int startIndex, @PathParam("length") int length) {
try {
PaginationResult paginationResult = DeviceMgtAPIUtils.getGroupManagementProviderService()
.getGroups(startIndex, length);
if (paginationResult.getRecordsTotal() > 0) {
return Response.status(Response.Status.OK).entity(paginationResult).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@Path("/all")
@GET
@Produces("application/json")
public Response getAllGroups() {
try {
GroupManagementProviderService groupManagementProviderService = DeviceMgtAPIUtils
.getGroupManagementProviderService();
PaginationResult paginationResult = groupManagementProviderService
.getGroups(0, groupManagementProviderService.getGroupCount());
if (paginationResult.getRecordsTotal() > 0) {
return Response.status(Response.Status.OK).entity(paginationResult.getData()).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@Path("/user/{user}")
@GET
@Produces("application/json")
public Response getGroups(@PathParam("user") String userName, @QueryParam("start") int startIndex,
@QueryParam("length") int length) {
try {
PaginationResult paginationResult = DeviceMgtAPIUtils.getGroupManagementProviderService()
.getGroups(userName, startIndex, length);
if (paginationResult.getRecordsTotal() > 0) {
return Response.status(Response.Status.OK).entity(paginationResult).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@Path("/user/{user}/all")
@GET
@Produces("application/json")
public Response getGroups(@PathParam("user") String userName) {
try {
List<DeviceGroup> deviceGroups = DeviceMgtAPIUtils.getGroupManagementProviderService()
.getGroups(userName);
if (deviceGroups.size() > 0) {
return Response.status(Response.Status.OK).entity(deviceGroups).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@Path("/owner/{owner}/name/{groupName}")
@GET
@Produces("application/json")
public Response getGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner) {
try {
DeviceGroup deviceGroup = DeviceMgtAPIUtils.getGroupManagementProviderService().getGroup(groupName, owner);
if (deviceGroup != null) {
return Response.status(Response.Status.OK).entity(deviceGroup).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@Path("/user/{user}/search")
@GET
@Produces("application/json")
public Response findGroups(@QueryParam("groupName") String groupName, @PathParam("user") String user) {
try {
List<DeviceGroup> groups = DeviceMgtAPIUtils.getGroupManagementProviderService()
.findInGroups(groupName, user);
DeviceGroup[] deviceGroups = new DeviceGroup[groups.size()];
groups.toArray(deviceGroups);
return Response.status(Response.Status.OK).entity(deviceGroups).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@Path("/user/{user}/all")
@GET
@Produces("application/json")
public Response getGroups(@PathParam("user") String userName, @QueryParam("permission") String permission) {
try {
GroupManagementProviderService groupManagementService = DeviceMgtAPIUtils.getGroupManagementProviderService();
List<DeviceGroup> groups;
if (permission != null) {
groups = groupManagementService.getGroups(userName, permission);
} else {
groups = groupManagementService.getGroups(userName);
}
DeviceGroup[] deviceGroups = new DeviceGroup[groups.size()];
groups.toArray(deviceGroups);
return Response.status(Response.Status.OK).entity(deviceGroups).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@Path("/count")
@GET
@Produces("application/json")
public Response getAllGroupCount() {
try {
int count = DeviceMgtAPIUtils.getGroupManagementProviderService().getGroupCount();
return Response.status(Response.Status.OK).entity(count).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@Path("/user/{user}/count")
@GET
@Produces("application/json")
public Response getGroupCount(@PathParam("user") String userName) {
try {
int count = DeviceMgtAPIUtils.getGroupManagementProviderService().getGroupCount(userName);
return Response.status(Response.Status.OK).entity(count).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@Path("/owner/{owner}/name/{groupName}/share")
@PUT
@Produces("application/json")
public Response shareGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@FormParam("shareUser") String shareUser,
@FormParam("roleName") String sharingRole) {
try {
boolean isShared = DeviceMgtAPIUtils.getGroupManagementProviderService().shareGroup(
shareUser, groupName, owner, sharingRole);
if (isShared) {
return Response.status(Response.Status.OK).build();
} else {
return Response.status(Response.Status.NOT_FOUND).entity("Group not found").build();
}
} catch (UserDoesNotExistException e) {
return Response.status(Response.Status.NOT_FOUND).entity(e.getMessage()).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@Path("/owner/{owner}/name/{groupName}/unshare")
@PUT
@Produces("application/json")
public Response unShareGroup(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@FormParam("unShareUser") String unShareUser,
@FormParam("roleName") String sharingRole) {
try {
boolean isUnShared = DeviceMgtAPIUtils.getGroupManagementProviderService().unshareGroup(
unShareUser, groupName, owner, sharingRole);
if (isUnShared) {
return Response.status(Response.Status.OK).build();
} else {
return Response.status(Response.Status.NOT_FOUND).entity("Group not found").build();
}
} catch (UserDoesNotExistException e) {
return Response.status(Response.Status.NOT_FOUND).entity(e.getMessage()).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@Path("/owner/{owner}/name/{groupName}/share/roles/{roleName}/permissions")
@PUT
@Produces("application/json")
public Response addSharing(@QueryParam("shareUser") String shareUser,
@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@PathParam("roleName") String roleName,
@FormParam("permissions") String[] permissions) {
try {
boolean isAdded = DeviceMgtAPIUtils.getGroupManagementProviderService().addGroupSharingRole(
shareUser, groupName, owner, roleName, permissions);
if (isAdded) {
return Response.status(Response.Status.OK).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@DELETE
@Path("/owner/{owner}/name/{groupName}/share/roles/{roleName}/permissions")
@Produces("application/json")
public Response removeSharing(@QueryParam("userName") String userName,
@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@PathParam("roleName") String roleName) {
try {
boolean isRemoved = DeviceMgtAPIUtils.getGroupManagementProviderService().removeGroupSharingRole(
groupName, owner, roleName);
if (isRemoved) {
return Response.status(Response.Status.OK).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@GET
@Path("/owner/{owner}/name/{groupName}/share/roles")
@Produces("application/json")
public Response getRoles(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@QueryParam("userName") String userName) {
try {
List<String> roles;
if (userName != null && !userName.isEmpty()) {
roles = DeviceMgtAPIUtils.getGroupManagementProviderService().getRoles(userName, groupName, owner);
} else {
roles = DeviceMgtAPIUtils.getGroupManagementProviderService().getRoles(groupName, owner);
}
String[] rolesArray = new String[roles.size()];
roles.toArray(rolesArray);
return Response.status(Response.Status.OK).entity(rolesArray).build();
} catch (UserDoesNotExistException e) {
return Response.status(Response.Status.NOT_FOUND).entity(e.getMessage()).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@PUT
@Path("/owner/{owner}/name/{groupName}/user/{userName}/share/roles")
@Produces("application/json")
public Response setRoles(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@PathParam("userName") String userName, List<String> selectedRoles) {
try {
List<String> allRoles = DeviceMgtAPIUtils.getGroupManagementProviderService().getRoles(groupName, owner);
for (String role : allRoles) {
if (selectedRoles.contains(role)) {
DeviceMgtAPIUtils.getGroupManagementProviderService()
.shareGroup(userName, groupName, owner, role);
} else {
DeviceMgtAPIUtils.getGroupManagementProviderService()
.unshareGroup(userName, groupName, owner, role);
}
}
return Response.status(Response.Status.OK).build();
} catch (UserDoesNotExistException e) {
return Response.status(Response.Status.NOT_FOUND).entity(e.getMessage()).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@GET
@Path("/owner/{owner}/name/{groupName}/users")
@Produces("application/json")
public Response getUsers(@PathParam("groupName") String groupName, @PathParam("owner") String owner) {
try {
List<GroupUser> users = DeviceMgtAPIUtils.getGroupManagementProviderService().getUsers(
groupName, owner);
GroupUser[] usersArray = new GroupUser[users.size()];
users.toArray(usersArray);
return Response.status(Response.Status.OK).entity(usersArray).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@GET
@Path("/owner/{owner}/name/{groupName}/devices")
@Produces("application/json")
public Response getDevices(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@QueryParam("start") int startIdx, @QueryParam("length") int length) {
try {
PaginationResult paginationResult = DeviceMgtAPIUtils
.getGroupManagementProviderService().getDevices(groupName, owner, startIdx, length);
if (paginationResult.getRecordsTotal() > 0) {
return Response.status(Response.Status.OK).entity(paginationResult).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@GET
@Path("/owner/{owner}/name/{groupName}/devices/count")
@Produces("application/json")
public Response getDeviceCount(@PathParam("groupName") String groupName, @PathParam("owner") String owner) {
try {
int count = DeviceMgtAPIUtils.getGroupManagementProviderService().getDeviceCount(groupName, owner);
return Response.status(Response.Status.OK).entity(count).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@POST
@Path("/owner/{owner}/name/{groupName}/devices")
@Produces("application/json")
public Response addDevice(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
DeviceIdentifier deviceIdentifier) {
try {
boolean isAdded = DeviceMgtAPIUtils.getGroupManagementProviderService().addDevice(
deviceIdentifier, groupName, owner);
if (isAdded) {
return Response.status(Response.Status.OK).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@DELETE
@Path("/owner/{owner}/name/{groupName}/devices/{deviceType}/{deviceId}")
@Produces("application/json")
public Response removeDevice(@PathParam("groupName") String groupName, @PathParam("owner") String owner,
@PathParam("deviceId") String deviceId,
@PathParam("deviceType") String deviceType) {
try {
DeviceIdentifier deviceIdentifier = new DeviceIdentifier(deviceId, deviceType);
boolean isRemoved = DeviceMgtAPIUtils.getGroupManagementProviderService().removeDevice(
deviceIdentifier, groupName, owner);
if (isRemoved) {
return Response.status(Response.Status.OK).build();
} else {
return Response.status(Response.Status.NOT_FOUND).build();
}
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
@Override
@GET
@Path("/owner/{owner}/name/{groupName}/users/{userName}/permissions")
@Produces("application/json")
public Response getPermissions(@PathParam("userName") String userName,
@PathParam("groupName") String groupName, @PathParam("owner") String owner) {
try {
String[] permissions = DeviceMgtAPIUtils.getGroupManagementProviderService()
.getPermissions(userName, groupName, owner);
return Response.status(Response.Status.OK).entity(permissions).build();
} catch (UserDoesNotExistException e) {
return Response.status(Response.Status.NOT_FOUND).entity(e.getMessage()).build();
} catch (GroupManagementException e) {
log.error(e.getMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
}
}

@ -0,0 +1,102 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.jaxrs.api.License;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
/**
* This class represents license related operations.
*/
@SuppressWarnings("NonJaxWsWebServices")
public class LicenseImpl implements License {
private static Log log = LogFactory.getLog(LicenseImpl.class);
/**
* This method returns the license text related to a given device type and language code.
*
* @param deviceType Device type, ex: android, ios
* @param languageCode Language code, ex: en_US
* @return Returns the license text
*/
@GET
@Path ("{deviceType}/{languageCode}")
@Produces ({MediaType.APPLICATION_JSON})
public Response getLicense(@PathParam ("deviceType") String deviceType,
@PathParam("languageCode") String languageCode) {
org.wso2.carbon.device.mgt.common.license.mgt.License license;
ResponsePayload responsePayload;
try {
license = DeviceMgtAPIUtils.getDeviceManagementService().getLicense(deviceType, languageCode);
if (license == null) {
return Response.status(HttpStatus.SC_NOT_FOUND).build();
}
responsePayload = ResponsePayload.statusCode(HttpStatus.SC_OK).
messageFromServer("License for '" + deviceType + "' was retrieved successfully").
responseContent(license.getText()).
build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while retrieving the license configured for '" + deviceType + "' device type";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* This method is used to add license to a specific device type.
*
* @param deviceType Device type, ex: android, ios
* @param license License object
* @return Returns the acknowledgement for the action
*/
@POST
@Path ("{deviceType}")
public Response addLicense(@PathParam ("deviceType") String deviceType,
org.wso2.carbon.device.mgt.common.license.mgt.License license) {
ResponsePayload responsePayload;
try {
DeviceMgtAPIUtils.getDeviceManagementService().addLicense(deviceType, license);
responsePayload = ResponsePayload.statusCode(HttpStatus.SC_OK).
messageFromServer("License added successfully for '" + deviceType + "' device type").
build();
} catch (DeviceManagementException e) {
String msg = "Error occurred while adding license for '" + deviceType + "' device type";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
}

@ -0,0 +1,227 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException;
import org.wso2.carbon.device.mgt.jaxrs.api.context.DeviceOperationContext;
import org.wso2.carbon.device.mgt.jaxrs.api.util.MDMIOSOperationUtil;
import org.wso2.carbon.device.mgt.jaxrs.beans.ApplicationWrapper;
import org.wso2.carbon.device.mgt.jaxrs.beans.MobileApp;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.PaginationRequest;
import org.wso2.carbon.device.mgt.common.PaginationResult;
import org.wso2.carbon.device.mgt.common.Platform;
import org.wso2.carbon.device.mgt.common.app.mgt.Application;
import org.wso2.carbon.device.mgt.common.app.mgt.ApplicationManagementException;
import org.wso2.carbon.device.mgt.common.app.mgt.ApplicationManager;
import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManagementException;
import org.wso2.carbon.device.mgt.core.app.mgt.ApplicationManagementProviderService;
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.api.util.MDMAndroidOperationUtil;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Response;
import java.util.List;
/**
* Operation related REST-API implementation.
*/
@SuppressWarnings("NonJaxWsWebServices")
@Produces({"application/json", "application/xml"})
@Consumes({"application/json", "application/xml"})
public class OperationImpl implements org.wso2.carbon.device.mgt.jaxrs.api.Operation {
private static Log log = LogFactory.getLog(OperationImpl.class);
/* @deprecated */
@Override
@GET
public Response getAllOperations() {
List<? extends org.wso2.carbon.device.mgt.common.operation.mgt.Operation> operations;
DeviceManagementProviderService dmService;
try {
dmService = DeviceMgtAPIUtils.getDeviceManagementService();
operations = dmService.getOperations(null);
} catch (OperationManagementException e) {
String msg = "Error occurred while fetching the operations for the device.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).entity(operations).build();
}
@Override
@GET
@Path("paginate/{type}/{id}")
public Response getDeviceOperations(@PathParam("type") String type, @PathParam("id") String id,
@QueryParam("start") int startIdx, @QueryParam("length") int length,
@QueryParam("search") String search) {
PaginationResult operations;
DeviceManagementProviderService dmService;
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
PaginationRequest paginationRequest = new PaginationRequest(startIdx, length);
try {
deviceIdentifier.setType(type);
deviceIdentifier.setId(id);
dmService = DeviceMgtAPIUtils.getDeviceManagementService();
operations = dmService.getOperations(deviceIdentifier, paginationRequest);
} catch (OperationManagementException e) {
String msg = "Error occurred while fetching the operations for the device.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).entity(operations).build();
}
@Override
@GET
@Path("{type}/{id}")
public Response getDeviceOperations(@PathParam("type") String type, @PathParam("id") String id) {
List<? extends org.wso2.carbon.device.mgt.common.operation.mgt.Operation> operations;
DeviceManagementProviderService dmService;
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
try {
deviceIdentifier.setType(type);
deviceIdentifier.setId(id);
dmService = DeviceMgtAPIUtils.getDeviceManagementService();
operations = dmService.getOperations(deviceIdentifier);
} catch (OperationManagementException e) {
String msg = "Error occurred while fetching the operations for the device.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).entity(operations).build();
}
/* @deprecated */
@Override
@POST
public Response addOperation(DeviceOperationContext operationContext) {
DeviceManagementProviderService dmService;
ResponsePayload responseMsg = new ResponsePayload();
try {
dmService = DeviceMgtAPIUtils.getDeviceManagementService();
int operationId = dmService.addOperation(operationContext.getOperation(), operationContext.getDevices());
if (operationId > 0) {
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
responseMsg.setMessageFromServer("Operation has added successfully.");
}
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (OperationManagementException e) {
String msg = "Error occurred while saving the operation";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@Override
@GET
@Path("{type}/{id}/apps")
public Response getInstalledApps(@PathParam("type") String type, @PathParam("id") String id) {
List<Application> applications;
ApplicationManagementProviderService appManagerConnector;
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
try {
deviceIdentifier.setType(type);
deviceIdentifier.setId(id);
appManagerConnector = DeviceMgtAPIUtils.getAppManagementService();
applications = appManagerConnector.getApplicationListForDevice(deviceIdentifier);
} catch (ApplicationManagementException e) {
String msg = "Error occurred while fetching the apps of the device.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.CREATED).entity(applications).build();
}
@Override
@POST
@Path("installApp/{tenantDomain}")
public Response installApplication(ApplicationWrapper applicationWrapper,
@PathParam("tenantDomain") String tenantDomain) {
ResponsePayload responseMsg = new ResponsePayload();
ApplicationManager appManagerConnector;
org.wso2.carbon.device.mgt.common.operation.mgt.Operation operation = null;
try {
appManagerConnector = DeviceMgtAPIUtils.getAppManagementService();
MobileApp mobileApp = applicationWrapper.getApplication();
if (applicationWrapper.getDeviceIdentifiers() != null) {
for (DeviceIdentifier deviceIdentifier : applicationWrapper.getDeviceIdentifiers()) {
if (deviceIdentifier.getType().equals(Platform.android.toString())) {
operation = MDMAndroidOperationUtil.createInstallAppOperation(mobileApp);
} else if (deviceIdentifier.getType().equals(Platform.ios.toString())) {
operation = MDMIOSOperationUtil.createInstallAppOperation(mobileApp);
}
}
appManagerConnector.installApplicationForDevices(operation, applicationWrapper.getDeviceIdentifiers());
}
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
responseMsg.setMessageFromServer("Authentication installation request has been sent to the device.");
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (ApplicationManagementException | MDMAPIException e) {
String msg = "Error occurred while saving the operation";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@Override
@POST
@Path("uninstallApp/{tenantDomain}")
public Response uninstallApplication(ApplicationWrapper applicationWrapper,
@PathParam("tenantDomain") String tenantDomain) {
ResponsePayload responseMsg = new ResponsePayload();
ApplicationManager appManagerConnector;
org.wso2.carbon.device.mgt.common.operation.mgt.Operation operation = null;
try {
appManagerConnector = DeviceMgtAPIUtils.getAppManagementService();
MobileApp mobileApp = applicationWrapper.getApplication();
if (applicationWrapper.getDeviceIdentifiers() != null) {
for (DeviceIdentifier deviceIdentifier : applicationWrapper.getDeviceIdentifiers()) {
if (deviceIdentifier.getType().equals(Platform.android.toString())) {
operation = MDMAndroidOperationUtil.createAppUninstallOperation(mobileApp);
} else if (deviceIdentifier.getType().equals(Platform.ios.toString())) {
operation = MDMIOSOperationUtil.createAppUninstallOperation(mobileApp);
}
}
appManagerConnector.installApplicationForDevices(operation, applicationWrapper.getDeviceIdentifiers());
}
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
responseMsg.setMessageFromServer("Authentication removal request has been sent to the device.");
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (ApplicationManagementException | MDMAPIException e) {
String msg = "Error occurred while saving the operation";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
}

@ -0,0 +1,445 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.beans.PriorityUpdatedPolicyWrapper;
import org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtUtil;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.device.mgt.jaxrs.beans.PolicyWrapper;
import org.wso2.carbon.policy.mgt.common.PolicyAdministratorPoint;
import org.wso2.carbon.policy.mgt.common.PolicyManagementException;
import org.wso2.carbon.policy.mgt.common.PolicyMonitoringTaskException;
import org.wso2.carbon.policy.mgt.common.monitor.ComplianceData;
import org.wso2.carbon.policy.mgt.common.monitor.PolicyComplianceException;
import org.wso2.carbon.policy.mgt.core.PolicyManagerService;
import org.wso2.carbon.policy.mgt.core.task.TaskScheduleService;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.ArrayList;
import java.util.List;
@SuppressWarnings("NonJaxWsWebServices")
public class PolicyImpl implements org.wso2.carbon.device.mgt.jaxrs.api.Policy {
private static Log log = LogFactory.getLog(PolicyImpl.class);
@Override
@POST
@Path("inactive-policy")
public Response addPolicy(PolicyWrapper policyWrapper) {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
ResponsePayload responseMsg = new ResponsePayload();
org.wso2.carbon.policy.mgt.common.Policy policy = new org.wso2.carbon.policy.mgt.common.Policy();
policy.setPolicyName(policyWrapper.getPolicyName());
policy.setProfileId(policyWrapper.getProfileId());
policy.setDescription(policyWrapper.getDescription());
policy.setProfile(DeviceMgtUtil.convertProfile(policyWrapper.getProfile()));
policy.setOwnershipType(policyWrapper.getOwnershipType());
policy.setRoles(policyWrapper.getRoles());
policy.setUsers(policyWrapper.getUsers());
policy.setTenantId(policyWrapper.getTenantId());
policy.setCompliance(policyWrapper.getCompliance());
return addPolicy(policyManagementService, responseMsg, policy);
}
@Override
@POST
@Path("active-policy")
public Response addActivePolicy(PolicyWrapper policyWrapper) {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
ResponsePayload responseMsg = new ResponsePayload();
org.wso2.carbon.policy.mgt.common.Policy policy = new org.wso2.carbon.policy.mgt.common.Policy();
policy.setPolicyName(policyWrapper.getPolicyName());
policy.setProfileId(policyWrapper.getProfileId());
policy.setDescription(policyWrapper.getDescription());
policy.setProfile(DeviceMgtUtil.convertProfile(policyWrapper.getProfile()));
policy.setOwnershipType(policyWrapper.getOwnershipType());
policy.setRoles(policyWrapper.getRoles());
policy.setUsers(policyWrapper.getUsers());
policy.setTenantId(policyWrapper.getTenantId());
policy.setCompliance(policyWrapper.getCompliance());
policy.setActive(true);
return addPolicy(policyManagementService, responseMsg, policy);
}
private Response addPolicy(PolicyManagerService policyManagementService, ResponsePayload responseMsg,
org.wso2.carbon.policy.mgt.common.Policy policy) {
try {
PolicyAdministratorPoint pap = policyManagementService.getPAP();
pap.addPolicy(policy);
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
responseMsg.setMessageFromServer("Policy has been added successfully.");
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (PolicyManagementException e) {
String msg = "Policy Management related exception";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@Override
@GET
@Produces({MediaType.APPLICATION_JSON})
public Response getAllPolicies() {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
List<org.wso2.carbon.policy.mgt.common.Policy> policies;
try {
PolicyAdministratorPoint policyAdministratorPoint = policyManagementService.getPAP();
policies = policyAdministratorPoint.getPolicies();
} catch (PolicyManagementException e) {
String msg = "Policy Management related exception";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Sending all retrieved device policies.");
responsePayload.setResponseContent(policies);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@Override
@GET
@Produces({MediaType.APPLICATION_JSON})
@Path("{id}")
public Response getPolicy(@PathParam("id") int policyId) {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
final org.wso2.carbon.policy.mgt.common.Policy policy;
try {
PolicyAdministratorPoint policyAdministratorPoint = policyManagementService.getPAP();
policy = policyAdministratorPoint.getPolicy(policyId);
} catch (PolicyManagementException e) {
String msg = "Policy Management related exception";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
if (policy == null){
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_NOT_FOUND);
responsePayload.setMessageFromServer("Policy for ID " + policyId + " not found.");
return Response.status(Response.Status.NOT_FOUND).entity(responsePayload).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Sending all retrieved device policies.");
responsePayload.setResponseContent(policy);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@Override
@GET
@Path("count")
public Response getPolicyCount() {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
try {
PolicyAdministratorPoint policyAdministratorPoint = policyManagementService.getPAP();
Integer count = policyAdministratorPoint.getPolicyCount();
return Response.status(Response.Status.OK).entity(count).build();
} catch (PolicyManagementException e) {
String msg = "Policy Management related exception";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@Override
@PUT
@Path("{id}")
public Response updatePolicy(PolicyWrapper policyWrapper, @PathParam("id") int policyId) {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
ResponsePayload responseMsg = new ResponsePayload();
org.wso2.carbon.policy.mgt.common.Policy policy = new org.wso2.carbon.policy.mgt.common.Policy();
policy.setPolicyName(policyWrapper.getPolicyName());
policy.setId(policyId);
policy.setProfileId(policyWrapper.getProfileId());
policy.setDescription(policyWrapper.getDescription());
policy.setProfile(DeviceMgtUtil.convertProfile(policyWrapper.getProfile()));
policy.setOwnershipType(policyWrapper.getOwnershipType());
policy.setRoles(policyWrapper.getRoles());
policy.setUsers(policyWrapper.getUsers());
policy.setTenantId(policyWrapper.getTenantId());
policy.setCompliance(policyWrapper.getCompliance());
try {
PolicyAdministratorPoint pap = policyManagementService.getPAP();
pap.updatePolicy(policy);
responseMsg.setStatusCode(HttpStatus.SC_CREATED);
responseMsg.setMessageFromServer("Policy has been updated successfully.");
return Response.status(Response.Status.CREATED).entity(responseMsg).build();
} catch (PolicyManagementException e) {
String msg = "Policy Management related exception in policy update.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@Override
@PUT
@Path("priorities")
@Consumes({MediaType.APPLICATION_JSON})
@Produces({MediaType.APPLICATION_JSON})
public Response updatePolicyPriorities(List<PriorityUpdatedPolicyWrapper> priorityUpdatedPolicies) {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
List<org.wso2.carbon.policy.mgt.common.Policy> policiesToUpdate =
new ArrayList<>(priorityUpdatedPolicies.size());
int i;
for (i = 0; i < priorityUpdatedPolicies.size(); i++) {
org.wso2.carbon.policy.mgt.common.Policy policyObj = new org.wso2.carbon.policy.mgt.common.Policy();
policyObj.setId(priorityUpdatedPolicies.get(i).getId());
policyObj.setPriorityId(priorityUpdatedPolicies.get(i).getPriority());
policiesToUpdate.add(policyObj);
}
boolean policiesUpdated;
try {
PolicyAdministratorPoint pap = policyManagementService.getPAP();
policiesUpdated = pap.updatePolicyPriorities(policiesToUpdate);
} catch (PolicyManagementException e) {
String msg = "Exception in updating policy priorities.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
if (policiesUpdated) {
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Policy Priorities successfully updated.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
} else {
responsePayload.setStatusCode(HttpStatus.SC_BAD_REQUEST);
responsePayload.setMessageFromServer("Policy priorities did not update. Bad Request.");
return Response.status(Response.Status.BAD_REQUEST).entity(responsePayload).build();
}
}
@Override
@POST
@Path("bulk-remove")
@Consumes("application/json")
@Produces("application/json")
public Response bulkRemovePolicy(List<Integer> policyIds) {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
boolean policyDeleted = true;
try {
PolicyAdministratorPoint pap = policyManagementService.getPAP();
for(int i : policyIds) {
org.wso2.carbon.policy.mgt.common.Policy policy = pap.getPolicy(i);
if(!pap.deletePolicy(policy)){
policyDeleted = false;
}
}
} catch (PolicyManagementException e) {
String msg = "Exception in deleting policies.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
if (policyDeleted) {
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Policies have been successfully deleted.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
} else {
responsePayload.setStatusCode(HttpStatus.SC_BAD_REQUEST);
responsePayload.setMessageFromServer("Policy does not exist.");
return Response.status(Response.Status.BAD_REQUEST).entity(responsePayload).build();
}
}
@Override
@PUT
@Produces("application/json")
@Path("activate")
public Response activatePolicy(List<Integer> policyIds) {
try {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
PolicyAdministratorPoint pap = policyManagementService.getPAP();
for(int i : policyIds) {
pap.activatePolicy(i);
}
} catch (PolicyManagementException e) {
String msg = "Exception in activating policies.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Selected policies have been successfully activated.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@Override
@PUT
@Produces("application/json")
@Path("inactivate")
public Response inactivatePolicy(List<Integer> policyIds) throws MDMAPIException {
try {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
PolicyAdministratorPoint pap = policyManagementService.getPAP();
for(int i : policyIds) {
pap.inactivatePolicy(i);
}
} catch (PolicyManagementException e) {
String msg = "Exception in inactivating policies.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Selected policies have been successfully inactivated.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@Override
@PUT
@Produces("application/json")
@Path("apply-changes")
public Response applyChanges() {
try {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
PolicyAdministratorPoint pap = policyManagementService.getPAP();
pap.publishChanges();
} catch (PolicyManagementException e) {
String msg = "Exception in applying changes.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Changes have been successfully updated.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@Override
@GET
@Path("start-task/{milliseconds}")
public Response startTaskService(@PathParam("milliseconds") int monitoringFrequency) {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
try {
TaskScheduleService taskScheduleService = policyManagementService.getTaskScheduleService();
taskScheduleService.startTask(monitoringFrequency);
} catch (PolicyMonitoringTaskException e) {
String msg = "Policy Management related exception.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Policy monitoring service started successfully.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@Override
@GET
@Path("update-task/{milliseconds}")
public Response updateTaskService(@PathParam("milliseconds") int monitoringFrequency) {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
try {
TaskScheduleService taskScheduleService = policyManagementService.getTaskScheduleService();
taskScheduleService.updateTask(monitoringFrequency);
} catch (PolicyMonitoringTaskException e) {
String msg = "Policy Management related exception.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Policy monitoring service updated successfully.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@Override
@GET
@Path("stop-task")
public Response stopTaskService() {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
try {
TaskScheduleService taskScheduleService = policyManagementService.getTaskScheduleService();
taskScheduleService.stopTask();
} catch (PolicyMonitoringTaskException e) {
String msg = "Policy Management related exception.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Policy monitoring service stopped successfully.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
@Override
@GET
@Path("{type}/{id}")
public Response getComplianceDataOfDevice(@PathParam("type") String type, @PathParam("id") String id) {
try {
DeviceIdentifier deviceIdentifier = DeviceMgtAPIUtils.instantiateDeviceIdentifier(type, id);
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
ComplianceData complianceData = policyManagementService.getDeviceCompliance(deviceIdentifier);
return Response.status(Response.Status.OK).entity(complianceData).build();
} catch (PolicyComplianceException e) {
String msg = "Error occurred while getting the compliance data.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@Override
@GET
@Path("{type}/{id}/active-policy")
public Response getDeviceActivePolicy(@PathParam("type") String type, @PathParam("id") String id) {
try {
DeviceIdentifier deviceIdentifier = DeviceMgtAPIUtils.instantiateDeviceIdentifier(type, id);
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
org.wso2.carbon.policy.mgt.common.Policy policy = policyManagementService
.getAppliedPolicyToDevice(deviceIdentifier);
return Response.status(Response.Status.OK).entity(policy).build();
} catch (PolicyManagementException e) {
String msg = "Error occurred while getting the current policy.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
}

@ -0,0 +1,87 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.jaxrs.api.Profile;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.policy.mgt.common.PolicyAdministratorPoint;
import org.wso2.carbon.policy.mgt.common.PolicyManagementException;
import org.wso2.carbon.policy.mgt.core.PolicyManagerService;
import javax.ws.rs.DELETE;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.core.Response;
@SuppressWarnings("NonJaxWsWebServices")
public class ProfileImpl implements Profile{
private static Log log = LogFactory.getLog(ProfileImpl.class);
@POST
public Response addProfile(org.wso2.carbon.policy.mgt.common.Profile profile) {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
try {
PolicyAdministratorPoint pap = policyManagementService.getPAP();
profile = pap.addProfile(profile);
return Response.status(Response.Status.OK).entity(profile).build();
} catch (PolicyManagementException e) {
String msg = "Policy Management related exception";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@POST
@Path("{id}")
public Response updateProfile(org.wso2.carbon.policy.mgt.common.Profile profile,
@PathParam("id") String profileId) {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
ResponsePayload responseMsg = new ResponsePayload();
try {
PolicyAdministratorPoint pap = policyManagementService.getPAP();
pap.updateProfile(profile);
responseMsg.setMessageFromServer("Profile has been updated successfully.");
return Response.status(Response.Status.OK).entity(responseMsg).build();
} catch (PolicyManagementException e) {
String msg = "Policy Management related exception";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
@DELETE
@Path("{id}")
public Response deleteProfile(@PathParam("id") int profileId) {
PolicyManagerService policyManagementService = DeviceMgtAPIUtils.getPolicyManagementService();
ResponsePayload responseMsg = new ResponsePayload();
try {
PolicyAdministratorPoint pap = policyManagementService.getPAP();
org.wso2.carbon.policy.mgt.common.Profile profile = pap.getProfile(profileId);
pap.deleteProfile(profile);
responseMsg.setMessageFromServer("Profile has been deleted successfully.");
return Response.status(Response.Status.OK).entity(responseMsg).build();
} catch (PolicyManagementException e) {
String msg = "Policy Management related exception";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
}

@ -0,0 +1,450 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.CarbonConstants;
import org.wso2.carbon.base.MultitenantConstants;
import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.device.mgt.jaxrs.beans.RoleWrapper;
import org.wso2.carbon.device.mgt.jaxrs.util.SetReferenceTransformer;
import org.wso2.carbon.user.api.AuthorizationManager;
import org.wso2.carbon.user.api.Permission;
import org.wso2.carbon.user.api.UserRealm;
import org.wso2.carbon.user.api.UserStoreException;
import org.wso2.carbon.user.api.UserStoreManager;
import org.wso2.carbon.user.core.common.AbstractUserStoreManager;
import org.wso2.carbon.user.mgt.UserRealmProxy;
import org.wso2.carbon.user.mgt.common.UIPermissionNode;
import org.wso2.carbon.user.mgt.common.UserAdminException;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@SuppressWarnings("NonJaxWsWebServices")
public class RoleImpl implements org.wso2.carbon.device.mgt.jaxrs.api.Role {
private static Log log = LogFactory.getLog(RoleImpl.class);
/**
* Get user roles (except all internal roles) from system.
*
* @return A list of users
*/
@Override
@GET
@Produces({MediaType.APPLICATION_JSON})
public Response getRoles() {
List<String> filteredRoles;
try {
filteredRoles = getRolesFromUserStore();
} catch (MDMAPIException e) {
log.error(e.getErrorMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getErrorMessage()).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("All user roles were successfully retrieved.");
responsePayload.setResponseContent(filteredRoles);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get user roles by user store(except all internal roles) from system.
*
* @return A list of users
*/
@Override
@GET
@Path("{userStore}")
@Produces({MediaType.APPLICATION_JSON})
public Response getRoles(@PathParam("userStore") String userStore) {
String[] roles;
try {
AbstractUserStoreManager abstractUserStoreManager =
(AbstractUserStoreManager) DeviceMgtAPIUtils.getUserStoreManager();
if (log.isDebugEnabled()) {
log.debug("Getting the list of user roles");
}
roles = abstractUserStoreManager.getRoleNames(userStore + "/*", -1, false, true, true);
} catch (UserStoreException | MDMAPIException e) {
String msg = "Error occurred while retrieving the list of user roles.";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
// removing all internal roles and roles created for Service-providers
List<String> filteredRoles = new ArrayList<>();
for (String role : roles) {
if (!(role.startsWith("Internal/") || role.startsWith("Authentication/"))) {
filteredRoles.add(role);
}
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("All user roles were successfully retrieved.");
responsePayload.setResponseContent(filteredRoles);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get user roles by providing a filtering criteria(except all internal roles & system roles) from system.
*
* @return A list of users
*/
@Override
@GET
@Path("search")
@Produces({MediaType.APPLICATION_JSON})
public Response getMatchingRoles(@QueryParam("filter") String filter) {
String[] roles;
try {
AbstractUserStoreManager abstractUserStoreManager =
(AbstractUserStoreManager) DeviceMgtAPIUtils.getUserStoreManager();
if (log.isDebugEnabled()) {
log.debug("Getting the list of user roles using filter : " + filter);
}
roles = abstractUserStoreManager.getRoleNames("*" + filter + "*", -1, true, true, true);
} catch (UserStoreException | MDMAPIException e) {
String msg = "Error occurred while retrieving the list of user roles using the filter : " + filter;
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
// removing all internal roles and roles created for Service-providers
List<String> filteredRoles = new ArrayList<>();
for (String role : roles) {
if (!(role.startsWith("Internal/") || role.startsWith("Authentication/"))) {
filteredRoles.add(role);
}
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("All matching user roles were successfully retrieved.");
responsePayload.setResponseContent(filteredRoles);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get role permissions.
*
* @return list of permissions
*/
@Override
@GET
@Path("permissions")
@Produces({MediaType.APPLICATION_JSON})
public Response getPermissions(@QueryParam("rolename") String roleName) {
try {
final UserRealm userRealm = DeviceMgtAPIUtils.getUserRealm();
org.wso2.carbon.user.core.UserRealm userRealmCore = null;
final UIPermissionNode rolePermissions;
if (userRealm instanceof org.wso2.carbon.user.core.UserRealm) {
userRealmCore = (org.wso2.carbon.user.core.UserRealm) userRealm;
}
final UserRealmProxy userRealmProxy = new UserRealmProxy(userRealmCore);
rolePermissions = getUIPermissionNode(roleName, userRealmProxy);
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("All permissions retrieved");
responsePayload.setResponseContent(rolePermissions);
return Response.status(Response.Status.OK).entity(responsePayload).build();
} catch (UserAdminException | MDMAPIException e) {
String msg = "Error occurred while retrieving the user role";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Get user role of the system
*
* @return user role
*/
@Override
@GET
@Path("role")
@Produces({MediaType.APPLICATION_JSON})
public Response getRole(@QueryParam("rolename") String roleName) {
RoleWrapper roleWrapper = new RoleWrapper();
try {
final UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
final UserRealm userRealm = DeviceMgtAPIUtils.getUserRealm();
org.wso2.carbon.user.core.UserRealm userRealmCore = null;
if (userRealm instanceof org.wso2.carbon.user.core.UserRealm) {
userRealmCore = (org.wso2.carbon.user.core.UserRealm) userRealm;
}
final UserRealmProxy userRealmProxy = new UserRealmProxy(userRealmCore);
if (log.isDebugEnabled()) {
log.debug("Getting the list of user roles");
}
if (userStoreManager.isExistingRole(roleName)) {
roleWrapper.setRoleName(roleName);
roleWrapper.setUsers(userStoreManager.getUserListOfRole(roleName));
// Get the permission nodes and hand picking only device management and login perms
final UIPermissionNode rolePermissions = getUIPermissionNode(roleName, userRealmProxy);
ArrayList<String> permList = new ArrayList<>();
iteratePermissions(rolePermissions, permList);
roleWrapper.setPermissionList(rolePermissions);
String[] permListAr = new String[permList.size()];
roleWrapper.setPermissions(permList.toArray(permListAr));
}
} catch (UserStoreException | UserAdminException | MDMAPIException e) {
String msg = "Error occurred while retrieving the user role";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("All user roles were successfully retrieved.");
responsePayload.setResponseContent(roleWrapper);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
private UIPermissionNode getUIPermissionNode(String roleName, UserRealmProxy userRealmProxy)
throws UserAdminException {
final UIPermissionNode rolePermissions =
userRealmProxy.getRolePermissions(roleName, MultitenantConstants.SUPER_TENANT_ID);
UIPermissionNode[] deviceMgtPermissions = new UIPermissionNode[2];
for (UIPermissionNode permissionNode : rolePermissions.getNodeList()) {
if (permissionNode.getResourcePath().equals("/permission/admin")) {
for (UIPermissionNode node : permissionNode.getNodeList()) {
if (node.getResourcePath().equals("/permission/admin/device-mgt")) {
deviceMgtPermissions[0] = node;
} else if (node.getResourcePath().equals("/permission/admin/login")) {
deviceMgtPermissions[1] = node;
}
}
}
}
rolePermissions.setNodeList(deviceMgtPermissions);
return rolePermissions;
}
/**
* API is used to persist a new Role
*
* @param roleWrapper for role
* @return response
*/
@Override
@POST
@Produces({MediaType.APPLICATION_JSON})
public Response addRole(RoleWrapper roleWrapper) {
try {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
if (log.isDebugEnabled()) {
log.debug("Persisting the role to user store");
}
Permission[] permissions = null;
if (roleWrapper.getPermissions() != null && roleWrapper.getPermissions().length > 0) {
permissions = new Permission[roleWrapper.getPermissions().length];
for (int i = 0; i < permissions.length; i++) {
String permission = roleWrapper.getPermissions()[i];
permissions[i] = new Permission(permission, CarbonConstants.UI_PERMISSION_ACTION);
}
}
userStoreManager.addRole(roleWrapper.getRoleName(), roleWrapper.getUsers(), permissions);
} catch (UserStoreException | MDMAPIException e) {
String msg = e.getMessage();
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).build();
}
/**
* API is used to update a role Role
*
* @param roleWrapper for role
* @return response
*/
@Override
@PUT
@Produces({MediaType.APPLICATION_JSON})
public Response updateRole(@QueryParam("rolename") String roleName, RoleWrapper roleWrapper) {
String newRoleName = roleWrapper.getRoleName();
try {
final UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
final AuthorizationManager authorizationManager = DeviceMgtAPIUtils.getAuthorizationManager();
if (log.isDebugEnabled()) {
log.debug("Updating the role to user store");
}
if (newRoleName != null && !roleName.equals(newRoleName)) {
userStoreManager.updateRoleName(roleName, newRoleName);
}
if (roleWrapper.getUsers() != null) {
SetReferenceTransformer<String> transformer = new SetReferenceTransformer<>();
transformer.transform(Arrays.asList(userStoreManager.getUserListOfRole(newRoleName)),
Arrays.asList(roleWrapper.getUsers()));
final String[] usersToAdd = transformer.getObjectsToAdd().toArray(new String[transformer
.getObjectsToAdd().size()]);
final String[] usersToDelete = transformer.getObjectsToRemove().toArray(new String[transformer
.getObjectsToRemove().size()]);
userStoreManager.updateUserListOfRole(newRoleName, usersToDelete, usersToAdd);
}
if (roleWrapper.getPermissions() != null) {
// Delete all authorizations for the current role before authorizing the permission tree
authorizationManager.clearRoleAuthorization(roleName);
if (roleWrapper.getPermissions().length > 0) {
for (int i = 0; i < roleWrapper.getPermissions().length; i++) {
String permission = roleWrapper.getPermissions()[i];
authorizationManager.authorizeRole(roleName, permission, CarbonConstants.UI_PERMISSION_ACTION);
}
}
}
} catch (UserStoreException | MDMAPIException e) {
String msg = e.getMessage();
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).build();
}
/**
* API is used to delete a role and authorizations
*
* @param roleName to delete
* @return response
*/
@Override
@DELETE
@Produces({MediaType.APPLICATION_JSON})
public Response deleteRole(@QueryParam("rolename") String roleName) {
try {
final UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
final AuthorizationManager authorizationManager = DeviceMgtAPIUtils.getAuthorizationManager();
if (log.isDebugEnabled()) {
log.debug("Deleting the role in user store");
}
userStoreManager.deleteRole(roleName);
// Delete all authorizations for the current role before deleting
authorizationManager.clearRoleAuthorization(roleName);
} catch (UserStoreException | MDMAPIException e) {
String msg = "Error occurred while deleting the role: " + roleName;
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).build();
}
/**
* API is used to update users of a role
*
* @param roleName to update
* @param userList of the users
* @return response
*/
@Override
@PUT
@Path("users")
@Produces({MediaType.APPLICATION_JSON})
public Response updateUsers(@QueryParam("rolename") String roleName, List<String> userList) {
try {
final UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
if (log.isDebugEnabled()) {
log.debug("Updating the users of a role");
}
SetReferenceTransformer<String> transformer = new SetReferenceTransformer<>();
transformer.transform(Arrays.asList(userStoreManager.getUserListOfRole(roleName)),
userList);
final String[] usersToAdd = transformer.getObjectsToAdd().toArray(new String[transformer
.getObjectsToAdd().size()]);
final String[] usersToDelete = transformer.getObjectsToRemove().toArray(new String[transformer
.getObjectsToRemove().size()]);
userStoreManager.updateUserListOfRole(roleName, usersToDelete, usersToAdd);
} catch (UserStoreException | MDMAPIException e) {
String msg = "Error occurred while saving the users of the role: " + roleName;
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).build();
}
private ArrayList<String> iteratePermissions(UIPermissionNode uiPermissionNode, ArrayList<String> list) {
for (UIPermissionNode permissionNode : uiPermissionNode.getNodeList()) {
list.add(permissionNode.getResourcePath());
if (permissionNode.getNodeList() != null && permissionNode.getNodeList().length > 0) {
iteratePermissions(permissionNode, list);
}
}
return list;
}
/**
* This method is used to retrieve the role count of the system.
*
* @return returns the count.
*/
@Override
@GET
@Path("count")
public Response getRoleCount() {
try {
List<String> filteredRoles = getRolesFromUserStore();
Integer count = filteredRoles.size();
return Response.status(Response.Status.OK).entity(count).build();
} catch (MDMAPIException e) {
log.error(e.getErrorMessage(), e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(e.getErrorMessage()).build();
}
}
private List<String> getRolesFromUserStore() throws MDMAPIException {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
String[] roles;
try {
if (log.isDebugEnabled()) {
log.debug("Getting the list of user roles");
}
roles = userStoreManager.getRoleNames();
} catch (UserStoreException e) {
String msg = "Error occurred while retrieving the list of user roles.";
throw new MDMAPIException(msg, e);
}
// removing all internal roles and roles created for Service-providers
List<String> filteredRoles = new ArrayList<>();
for (String role : roles) {
if (!(role.startsWith("Internal/") || role.startsWith("Authentication/"))) {
filteredRoles.add(role);
}
}
return filteredRoles;
}
}

@ -0,0 +1,772 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.jaxrs.api.impl;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.context.CarbonContext;
import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException;
import org.wso2.carbon.device.mgt.jaxrs.beans.UserCredentialWrapper;
import org.wso2.carbon.device.mgt.jaxrs.beans.UserWrapper;
import org.wso2.carbon.device.mgt.jaxrs.util.Constants;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.PaginationRequest;
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
import org.wso2.carbon.device.mgt.core.service.EmailMetaInfo;
import org.wso2.carbon.device.mgt.jaxrs.api.util.CredentialManagementResponseBuilder;
import org.wso2.carbon.device.mgt.jaxrs.api.util.DeviceMgtAPIUtils;
import org.wso2.carbon.device.mgt.jaxrs.api.util.ResponsePayload;
import org.wso2.carbon.device.mgt.jaxrs.util.SetReferenceTransformer;
import org.wso2.carbon.user.api.UserStoreException;
import org.wso2.carbon.user.api.UserStoreManager;
import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Random;
import java.util.TreeSet;
/**
* This class represents the JAX-RS services of User related functionality.
*/
@SuppressWarnings("NonJaxWsWebServices")
public class UserImpl implements org.wso2.carbon.device.mgt.jaxrs.api.User {
private static final String ROLE_EVERYONE = "Internal/everyone";
private static Log log = LogFactory.getLog(UserImpl.class);
/**
* Method to add user to emm-user-store.
*
* @param userWrapper Wrapper object representing input json payload
* @return {Response} Status of the request wrapped inside Response object
*/
@Override
@POST
@Consumes({MediaType.APPLICATION_JSON})
@Produces({MediaType.APPLICATION_JSON})
public Response addUser(UserWrapper userWrapper) {
ResponsePayload responsePayload = new ResponsePayload();
try {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
if (userStoreManager.isExistingUser(userWrapper.getUsername())) {
// if user already exists
if (log.isDebugEnabled()) {
log.debug("User by username: " + userWrapper.getUsername() +
" already exists. Therefore, request made to add user was refused.");
}
// returning response with bad request state
responsePayload.setStatusCode(HttpStatus.SC_CONFLICT);
responsePayload.
setMessageFromServer("User by username: " + userWrapper.getUsername() +
" already exists. Therefore, request made to add user was refused.");
return Response.status(Response.Status.CONFLICT).entity(responsePayload).build();
} else {
String initialUserPassword = generateInitialUserPassword();
Map<String, String> defaultUserClaims =
buildDefaultUserClaims(userWrapper.getFirstname(), userWrapper.getLastname(),
userWrapper.getEmailAddress());
// calling addUser method of carbon user api
userStoreManager.addUser(userWrapper.getUsername(), initialUserPassword,
userWrapper.getRoles(), defaultUserClaims, null);
// invite newly added user to enroll device
inviteNewlyAddedUserToEnrollDevice(userWrapper.getUsername(), initialUserPassword);
// Outputting debug message upon successful addition of user
if (log.isDebugEnabled()) {
log.debug("User by username: " + userWrapper.getUsername() + " was successfully added.");
}
// returning response with success state
responsePayload.setStatusCode(HttpStatus.SC_CREATED);
responsePayload.setMessageFromServer("User by username: " + userWrapper.getUsername() +
" was successfully added.");
return Response.status(Response.Status.CREATED).entity(responsePayload).build();
}
} catch (UserStoreException | MDMAPIException e) {
String msg = "Exception in trying to add user by username: " + userWrapper.getUsername();
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Method to get user information from emm-user-store.
*
* @param username User-name of the user
* @return {Response} Status of the request wrapped inside Response object.
*/
@Override
@GET
@Path("view")
@Produces({MediaType.APPLICATION_JSON})
public Response getUser(@QueryParam("username") String username) {
ResponsePayload responsePayload = new ResponsePayload();
try {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
if (userStoreManager.isExistingUser(username)) {
UserWrapper user = new UserWrapper();
user.setUsername(username);
user.setEmailAddress(getClaimValue(username, Constants.USER_CLAIM_EMAIL_ADDRESS));
user.setFirstname(getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME));
user.setLastname(getClaimValue(username, Constants.USER_CLAIM_LAST_NAME));
// Outputting debug message upon successful retrieval of user
if (log.isDebugEnabled()) {
log.debug("User by username: " + username + " was found.");
}
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("User information was retrieved successfully.");
responsePayload.setResponseContent(user);
return Response.status(Response.Status.OK).entity(responsePayload).build();
} else {
// Outputting debug message upon trying to remove non-existing user
if (log.isDebugEnabled()) {
log.debug("User by username: " + username + " does not exist.");
}
// returning response with bad request state
responsePayload.setStatusCode(HttpStatus.SC_BAD_REQUEST);
responsePayload.setMessageFromServer(
"User by username: " + username + " does not exist.");
return Response.status(Response.Status.BAD_REQUEST).entity(responsePayload).build();
}
} catch (UserStoreException | MDMAPIException e) {
String msg = "Exception in trying to retrieve user by username: " + username;
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Update user in user store
*
* @param userWrapper Wrapper object representing input json payload
* @return {Response} Status of the request wrapped inside Response object.
*/
@Override
@PUT
@Consumes({MediaType.APPLICATION_JSON})
@Produces({MediaType.APPLICATION_JSON})
public Response updateUser(UserWrapper userWrapper, @QueryParam("username") String username) {
ResponsePayload responsePayload = new ResponsePayload();
try {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
if (userStoreManager.isExistingUser(userWrapper.getUsername())) {
Map<String, String> defaultUserClaims =
buildDefaultUserClaims(userWrapper.getFirstname(), userWrapper.getLastname(),
userWrapper.getEmailAddress());
if (StringUtils.isNotEmpty(userWrapper.getPassword())) {
// Decoding Base64 encoded password
byte[] decodedBytes = Base64.decodeBase64(userWrapper.getPassword());
userStoreManager.updateCredentialByAdmin(userWrapper.getUsername(),
new String(decodedBytes, "UTF-8"));
log.debug("User credential of username: " + userWrapper.getUsername() + " has been changed");
}
List<String> listofFilteredRoles = getFilteredRoles(userStoreManager, userWrapper.getUsername());
final String[] existingRoles = listofFilteredRoles.toArray(new String[listofFilteredRoles.size()]);
/*
Use the Set theory to find the roles to delete and roles to add
The difference of roles in existingRolesSet and newRolesSet needed to be deleted
new roles to add = newRolesSet - The intersection of roles in existingRolesSet and newRolesSet
*/
final TreeSet<String> existingRolesSet = new TreeSet<>();
Collections.addAll(existingRolesSet, existingRoles);
final TreeSet<String> newRolesSet = new TreeSet<>();
Collections.addAll(newRolesSet, userWrapper.getRoles());
existingRolesSet.removeAll(newRolesSet);
// Now we have the roles to delete
String[] rolesToDelete = existingRolesSet.toArray(new String[existingRolesSet.size()]);
List<String> roles = new ArrayList<>(Arrays.asList(rolesToDelete));
roles.remove(ROLE_EVERYONE);
rolesToDelete = new String[0];
// Clearing and re-initializing the set
existingRolesSet.clear();
Collections.addAll(existingRolesSet, existingRoles);
newRolesSet.removeAll(existingRolesSet);
// Now we have the roles to add
String[] rolesToAdd = newRolesSet.toArray(new String[newRolesSet.size()]);
userStoreManager.updateRoleListOfUser(userWrapper.getUsername(), rolesToDelete, rolesToAdd);
userStoreManager.setUserClaimValues(userWrapper.getUsername(), defaultUserClaims, null);
// Outputting debug message upon successful addition of user
if (log.isDebugEnabled()) {
log.debug("User by username: " + userWrapper.getUsername() + " was successfully updated.");
}
// returning response with success state
responsePayload.setStatusCode(HttpStatus.SC_CREATED);
responsePayload.setMessageFromServer("User by username: " + userWrapper.getUsername() +
" was successfully updated.");
return Response.status(Response.Status.CREATED).entity(responsePayload).build();
} else {
if (log.isDebugEnabled()) {
log.debug("User by username: " + userWrapper.getUsername() +
" doesn't exists. Therefore, request made to update user was refused.");
}
// returning response with bad request state
responsePayload.setStatusCode(HttpStatus.SC_CONFLICT);
responsePayload.
setMessageFromServer("User by username: " + userWrapper.getUsername() +
" doesn't exists. Therefore, request made to update user was refused.");
return Response.status(Response.Status.CONFLICT).entity(responsePayload).build();
}
} catch (UserStoreException | UnsupportedEncodingException | MDMAPIException e) {
String msg = "Exception in trying to update user by username: " + userWrapper.getUsername();
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Private method to be used by addUser() to
* generate an initial user password for a user.
* This will be the password used by a user for his initial login to the system.
*
* @return {string} Initial User Password
*/
private String generateInitialUserPassword() {
int passwordLength = 6;
//defining the pool of characters to be used for initial password generation
String lowerCaseCharset = "abcdefghijklmnopqrstuvwxyz";
String upperCaseCharset = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
String numericCharset = "0123456789";
Random randomGenerator = new Random();
String totalCharset = lowerCaseCharset + upperCaseCharset + numericCharset;
int totalCharsetLength = totalCharset.length();
StringBuilder initialUserPassword = new StringBuilder();
for (int i = 0; i < passwordLength; i++) {
initialUserPassword
.append(totalCharset.charAt(randomGenerator.nextInt(totalCharsetLength)));
}
if (log.isDebugEnabled()) {
log.debug("Initial user password is created for new user: " + initialUserPassword);
}
return initialUserPassword.toString();
}
/**
* Method to build default user claims.
*
* @param firstname First name of the user
* @param lastname Last name of the user
* @param emailAddress Email address of the user
* @return {Object} Default user claims to be provided
*/
private Map<String, String> buildDefaultUserClaims(String firstname, String lastname, String emailAddress) {
Map<String, String> defaultUserClaims = new HashMap<>();
defaultUserClaims.put(Constants.USER_CLAIM_FIRST_NAME, firstname);
defaultUserClaims.put(Constants.USER_CLAIM_LAST_NAME, lastname);
defaultUserClaims.put(Constants.USER_CLAIM_EMAIL_ADDRESS, emailAddress);
if (log.isDebugEnabled()) {
log.debug("Default claim map is created for new user: " + defaultUserClaims.toString());
}
return defaultUserClaims;
}
/**
* Method to remove user from emm-user-store.
*
* @param username Username of the user
* @return {Response} Status of the request wrapped inside Response object.
*/
@Override
@DELETE
@Produces({MediaType.APPLICATION_JSON})
public Response removeUser(@QueryParam("username") String username) {
ResponsePayload responsePayload = new ResponsePayload();
try {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
if (userStoreManager.isExistingUser(username)) {
// if user already exists, trying to remove user
userStoreManager.deleteUser(username);
// Outputting debug message upon successful removal of user
if (log.isDebugEnabled()) {
log.debug("User by username: " + username + " was successfully removed.");
}
// returning response with success state
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer(
"User by username: " + username + " was successfully removed.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
} else {
// Outputting debug message upon trying to remove non-existing user
if (log.isDebugEnabled()) {
log.debug("User by username: " + username + " does not exist for removal.");
}
// returning response with bad request state
responsePayload.setStatusCode(HttpStatus.SC_BAD_REQUEST);
responsePayload.setMessageFromServer(
"User by username: " + username + " does not exist for removal.");
return Response.status(Response.Status.BAD_REQUEST).entity(responsePayload).build();
}
} catch (UserStoreException | MDMAPIException e) {
String msg = "Exception in trying to remove user by username: " + username;
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* get all the roles except for the internal/xxx and application/xxx
*
* @param userStoreManager User Store Manager associated with the currently logged in user
* @param username Username of the currently logged in user
* @return the list of filtered roles
*/
private List<String> getFilteredRoles(UserStoreManager userStoreManager, String username) {
String[] roleListOfUser = new String[0];
try {
roleListOfUser = userStoreManager.getRoleListOfUser(username);
} catch (UserStoreException e) {
e.printStackTrace();
}
List<String> filteredRoles = new ArrayList<>();
for (String role : roleListOfUser) {
if (!(role.startsWith("Internal/") || role.startsWith("Authentication/"))) {
filteredRoles.add(role);
}
}
return filteredRoles;
}
/**
* Get user's roles by username
*
* @param username Username of the user
* @return {Response} Status of the request wrapped inside Response object.
*/
@Override
@GET
@Path("roles")
@Produces({MediaType.APPLICATION_JSON})
public Response getRoles(@QueryParam("username") String username) {
ResponsePayload responsePayload = new ResponsePayload();
try {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
if (userStoreManager.isExistingUser(username)) {
responsePayload.setResponseContent(Collections.singletonList(getFilteredRoles(userStoreManager, username)));
// Outputting debug message upon successful removal of user
if (log.isDebugEnabled()) {
log.debug("User by username: " + username + " was successfully removed.");
}
// returning response with success state
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer(
"User roles obtained for user " + username);
return Response.status(Response.Status.OK).entity(responsePayload).build();
} else {
// Outputting debug message upon trying to remove non-existing user
if (log.isDebugEnabled()) {
log.debug("User by username: " + username + " does not exist for role retrieval.");
}
// returning response with bad request state
responsePayload.setStatusCode(HttpStatus.SC_BAD_REQUEST);
responsePayload.setMessageFromServer(
"User by username: " + username + " does not exist for role retrieval.");
return Response.status(Response.Status.BAD_REQUEST).entity(responsePayload).build();
}
} catch (UserStoreException | MDMAPIException e) {
String msg = "Exception in trying to retrieve roles for user by username: " + username;
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* Get the list of all users with all user-related info.
*
* @return A list of users
*/
@Override
@GET
@Produces({MediaType.APPLICATION_JSON})
public Response getAllUsers() {
if (log.isDebugEnabled()) {
log.debug("Getting the list of users with all user-related information");
}
List<UserWrapper> userList;
try {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
String[] users = userStoreManager.listUsers("*", -1);
userList = new ArrayList<>(users.length);
UserWrapper user;
for (String username : users) {
user = new UserWrapper();
user.setUsername(username);
user.setEmailAddress(getClaimValue(username, Constants.USER_CLAIM_EMAIL_ADDRESS));
user.setFirstname(getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME));
user.setLastname(getClaimValue(username, Constants.USER_CLAIM_LAST_NAME));
userList.add(user);
}
} catch (UserStoreException | MDMAPIException e) {
String msg = "Error occurred while retrieving the list of users";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
int count;
count = userList.size();
responsePayload.setMessageFromServer("All users were successfully retrieved. " +
"Obtained user count: " + count);
responsePayload.setResponseContent(userList);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get the list of all users with all user-related info.
*
* @return A list of users
*/
@Override
@GET
@Path("{filter}")
@Produces({MediaType.APPLICATION_JSON})
public Response getMatchingUsers(@PathParam("filter") String filter) {
if (log.isDebugEnabled()) {
log.debug("Getting the list of users with all user-related information using the filter : " + filter);
}
List<UserWrapper> userList;
try {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
String[] users = userStoreManager.listUsers(filter + "*", -1);
userList = new ArrayList<>(users.length);
UserWrapper user;
for (String username : users) {
user = new UserWrapper();
user.setUsername(username);
user.setEmailAddress(getClaimValue(username, Constants.USER_CLAIM_EMAIL_ADDRESS));
user.setFirstname(getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME));
user.setLastname(getClaimValue(username, Constants.USER_CLAIM_LAST_NAME));
userList.add(user);
}
} catch (UserStoreException | MDMAPIException e) {
String msg = "Error occurred while retrieving the list of users using the filter : " + filter;
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
int count;
count = userList.size();
responsePayload.setMessageFromServer("All users were successfully retrieved. " +
"Obtained user count: " + count);
responsePayload.setResponseContent(userList);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get the list of user names in the system.
*
* @return A list of user names.
*/
@Override
@GET
@Path("view-users")
public Response getAllUsersByUsername(@QueryParam("username") String userName) {
if (log.isDebugEnabled()) {
log.debug("Getting the list of users by name");
}
List<UserWrapper> userList;
try {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
String[] users = userStoreManager.listUsers("*" + userName + "*", -1);
userList = new ArrayList<>(users.length);
UserWrapper user;
for (String username : users) {
user = new UserWrapper();
user.setUsername(username);
user.setEmailAddress(getClaimValue(username, Constants.USER_CLAIM_EMAIL_ADDRESS));
user.setFirstname(getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME));
user.setLastname(getClaimValue(username, Constants.USER_CLAIM_LAST_NAME));
userList.add(user);
}
} catch (UserStoreException | MDMAPIException e) {
String msg = "Error occurred while retrieving the list of users";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
int count;
count = userList.size();
responsePayload.setMessageFromServer("All users by username were successfully retrieved. " +
"Obtained user count: " + count);
responsePayload.setResponseContent(userList);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get the list of user names in the system.
*
* @return A list of user names.
*/
@Override
@GET
@Path("users-by-username")
public Response getAllUserNamesByUsername(@QueryParam("username") String userName) {
if (log.isDebugEnabled()) {
log.debug("Getting the list of users by name");
}
List<String> userList;
try {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
String[] users = userStoreManager.listUsers("*" + userName + "*", -1);
userList = new ArrayList<>(users.length);
Collections.addAll(userList, users);
} catch (UserStoreException | MDMAPIException e) {
String msg = "Error occurred while retrieving the list of users";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
int count;
count = userList.size();
responsePayload.setMessageFromServer("All users by username were successfully retrieved. " +
"Obtained user count: " + count);
responsePayload.setResponseContent(userList);
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Gets a claim-value from user-store.
*
* @param username Username of the user
* @param claimUri required ClaimUri
* @return claim value
*/
private String getClaimValue(String username, String claimUri) throws MDMAPIException {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
try {
return userStoreManager.getUserClaimValue(username, claimUri, null);
} catch (UserStoreException e) {
throw new MDMAPIException("Error occurred while retrieving value assigned to the claim '" +
claimUri + "'", e);
}
}
/**
* Method used to send an invitation email to a new user to enroll a device.
*
* @param username Username of the user
*/
private void inviteNewlyAddedUserToEnrollDevice(String username, String password) throws MDMAPIException {
if (log.isDebugEnabled()) {
log.debug("Sending invitation mail to user by username: " + username);
}
String tenantDomain = CarbonContext.getThreadLocalCarbonContext().getTenantDomain();
if (MultitenantConstants.SUPER_TENANT_DOMAIN_NAME.equalsIgnoreCase(tenantDomain)) {
tenantDomain = "";
}
if (!username.contains("/")) {
username = "/" + username;
}
String[] usernameBits = username.split("/");
DeviceManagementProviderService deviceManagementProviderService = DeviceMgtAPIUtils.getDeviceManagementService();
Properties props = new Properties();
props.setProperty("username", usernameBits[1]);
props.setProperty("domain-name", tenantDomain);
props.setProperty("first-name", getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME));
props.setProperty("password", password);
String recipient = getClaimValue(username, Constants.USER_CLAIM_EMAIL_ADDRESS);
EmailMetaInfo metaInfo = new EmailMetaInfo(recipient, props);
try {
deviceManagementProviderService.sendRegistrationEmail(metaInfo);
} catch (DeviceManagementException e) {
String msg = "Error occurred while sending registration email to user '" + username + "'";
log.error(msg, e);
throw new MDMAPIException(msg, e);
}
}
/**
* Method used to send an invitation email to a existing user to enroll a device.
*
* @param usernames Username list of the users to be invited
*/
@Override
@POST
@Path("email-invitation")
@Produces({MediaType.APPLICATION_JSON})
public Response inviteExistingUsersToEnrollDevice(List<String> usernames) {
if (log.isDebugEnabled()) {
log.debug("Sending enrollment invitation mail to existing user.");
}
DeviceManagementProviderService deviceManagementProviderService = DeviceMgtAPIUtils.getDeviceManagementService();
try {
for (String username : usernames) {
String recipient = getClaimValue(username, Constants.USER_CLAIM_EMAIL_ADDRESS);
Properties props = new Properties();
props.setProperty("first-name", getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME));
props.setProperty("username", username);
EmailMetaInfo metaInfo = new EmailMetaInfo(recipient, props);
deviceManagementProviderService.sendEnrolmentInvitation(metaInfo);
}
} catch (DeviceManagementException | MDMAPIException e) {
String msg = "Error occurred while inviting user to enrol their device";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
ResponsePayload responsePayload = new ResponsePayload();
responsePayload.setStatusCode(HttpStatus.SC_OK);
responsePayload.setMessageFromServer("Email invitation was successfully sent to user.");
return Response.status(Response.Status.OK).entity(responsePayload).build();
}
/**
* Get a list of devices based on the username.
*
* @param username Username of the device owner
* @return A list of devices
*/
@Override
@GET
@Produces({MediaType.APPLICATION_JSON})
@Path("devices")
public Response getAllDeviceOfUser(@QueryParam("username") String username,
@QueryParam("start") int startIdx, @QueryParam("length") int length) {
DeviceManagementProviderService dmService;
try {
dmService = DeviceMgtAPIUtils.getDeviceManagementService();
if (length > 0) {
PaginationRequest request = new PaginationRequest(startIdx, length);
request.setOwner(username);
return Response.status(Response.Status.OK).entity(dmService.getDevicesOfUser(request)).build();
}
return Response.status(Response.Status.OK).entity(dmService.getDevicesOfUser(username)).build();
} catch (DeviceManagementException e) {
String msg = "Device management error";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* This method is used to retrieve the user count of the system.
*
* @return returns the count.
* @
*/
@Override
@GET
@Path("count")
public Response getUserCount() {
try {
String[] users = DeviceMgtAPIUtils.getUserStoreManager().listUsers("*", -1);
Integer count = 0;
if (users != null) {
count = users.length;
}
return Response.status(Response.Status.OK).entity(count).build();
} catch (UserStoreException | MDMAPIException e) {
String msg =
"Error occurred while retrieving the list of users that exist within the current tenant";
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
}
/**
* API is used to update roles of a user
*
* @param username
* @param userList
* @return
* @
*/
@Override
@PUT
@Path("{roleName}/users")
@Produces({MediaType.APPLICATION_JSON})
public Response updateRoles(@PathParam("username") String username, List<String> userList) {
try {
final UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
if (log.isDebugEnabled()) {
log.debug("Updating the roles of a user");
}
SetReferenceTransformer<String> transformer = new SetReferenceTransformer<>();
transformer.transform(Arrays.asList(userStoreManager.getRoleListOfUser(username)),
userList);
final String[] rolesToAdd = transformer.getObjectsToAdd().toArray(new String[transformer.getObjectsToAdd().size()]);
final String[] rolesToDelete = transformer.getObjectsToRemove().toArray(new String[transformer.getObjectsToRemove().size()]);
userStoreManager.updateRoleListOfUser(username, rolesToDelete, rolesToAdd);
} catch (UserStoreException | MDMAPIException e) {
String msg = "Error occurred while saving the roles for user: " + username;
log.error(msg, e);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
}
return Response.status(Response.Status.OK).build();
}
/**
* Method to change the user password.
*
* @param credentials Wrapper object representing user credentials.
* @return {Response} Status of the request wrapped inside Response object.
* @
*/
@Override
@POST
@Path("change-password")
@Consumes({MediaType.APPLICATION_JSON})
@Produces({MediaType.APPLICATION_JSON})
public Response resetPassword(UserCredentialWrapper credentials) {
return CredentialManagementResponseBuilder.buildChangePasswordResponse(credentials);
}
/**
* Method to change the user password.
*
* @param credentials Wrapper object representing user credentials.
* @return {Response} Status of the request wrapped inside Response object.
* @
*/
@Override
@POST
@Path("reset-password")
@Consumes({MediaType.APPLICATION_JSON})
@Produces({MediaType.APPLICATION_JSON})
public Response resetPasswordByAdmin(UserCredentialWrapper credentials) {
return CredentialManagementResponseBuilder.buildResetPasswordResponse(credentials);
}
}

@ -52,7 +52,7 @@ public class CredentialManagementResponseBuilder {
userStoreManager.updateCredential(credentials.getUsername(), new String( userStoreManager.updateCredential(credentials.getUsername(), new String(
decodedNewPassword, "UTF-8"), new String(decodedOldPassword, "UTF-8")); decodedNewPassword, "UTF-8"), new String(decodedOldPassword, "UTF-8"));
responsePayload.setStatusCode(HttpStatus.SC_CREATED); responsePayload.setStatusCode(HttpStatus.SC_CREATED);
responsePayload.setMessageFromServer("User password by username: " + credentials.getUsername() + responsePayload.setMessageFromServer("UserImpl password by username: " + credentials.getUsername() +
" was successfully changed."); " was successfully changed.");
return Response.status(Response.Status.CREATED).entity(responsePayload).build(); return Response.status(Response.Status.CREATED).entity(responsePayload).build();
} catch (UserStoreException e) { } catch (UserStoreException e) {
@ -84,7 +84,7 @@ public class CredentialManagementResponseBuilder {
userStoreManager.updateCredentialByAdmin(credentials.getUsername(), new String( userStoreManager.updateCredentialByAdmin(credentials.getUsername(), new String(
decodedNewPassword, "UTF-8")); decodedNewPassword, "UTF-8"));
responsePayload.setStatusCode(HttpStatus.SC_CREATED); responsePayload.setStatusCode(HttpStatus.SC_CREATED);
responsePayload.setMessageFromServer("User password by username: " + credentials.getUsername() + responsePayload.setMessageFromServer("UserImpl password by username: " + credentials.getUsername() +
" was successfully changed."); " was successfully changed.");
return Response.status(Response.Status.CREATED).entity(responsePayload).build(); return Response.status(Response.Status.CREATED).entity(responsePayload).build();
} catch (UserStoreException e) { } catch (UserStoreException e) {

@ -87,7 +87,7 @@ public class DeviceMgtAPIUtils {
DeviceManagementProviderService deviceManagementProviderService = DeviceManagementProviderService deviceManagementProviderService =
(DeviceManagementProviderService) ctx.getOSGiService(DeviceManagementProviderService.class, null); (DeviceManagementProviderService) ctx.getOSGiService(DeviceManagementProviderService.class, null);
if (deviceManagementProviderService == null) { if (deviceManagementProviderService == null) {
String msg = "Device Management provider service has not initialized."; String msg = "DeviceImpl Management provider service has not initialized.";
log.error(msg); log.error(msg);
throw new IllegalStateException(msg); throw new IllegalStateException(msg);
} }
@ -99,7 +99,7 @@ public class DeviceMgtAPIUtils {
GroupManagementProviderService groupManagementProviderService = GroupManagementProviderService groupManagementProviderService =
(GroupManagementProviderService) ctx.getOSGiService(GroupManagementProviderService.class, null); (GroupManagementProviderService) ctx.getOSGiService(GroupManagementProviderService.class, null);
if (groupManagementProviderService == null) { if (groupManagementProviderService == null) {
String msg = "Group Management service has not initialized."; String msg = "GroupImpl Management service has not initialized.";
log.error(msg); log.error(msg);
throw new IllegalStateException(msg); throw new IllegalStateException(msg);
} }
@ -213,7 +213,7 @@ public class DeviceMgtAPIUtils {
ApplicationManagementProviderService applicationManagementProviderService = ApplicationManagementProviderService applicationManagementProviderService =
(ApplicationManagementProviderService) ctx.getOSGiService(ApplicationManagementProviderService.class, null); (ApplicationManagementProviderService) ctx.getOSGiService(ApplicationManagementProviderService.class, null);
if (applicationManagementProviderService == null) { if (applicationManagementProviderService == null) {
String msg = "Application management service has not initialized."; String msg = "AuthenticationImpl management service has not initialized.";
log.error(msg); log.error(msg);
throw new IllegalStateException(msg); throw new IllegalStateException(msg);
} }
@ -226,7 +226,7 @@ public class DeviceMgtAPIUtils {
policyManagementService = policyManagementService =
(PolicyManagerService) ctx.getOSGiService(PolicyManagerService.class, null); (PolicyManagerService) ctx.getOSGiService(PolicyManagerService.class, null);
if (policyManagementService == null) { if (policyManagementService == null) {
String msg = "Policy Management service not initialized."; String msg = "PolicyImpl Management service not initialized.";
log.error(msg); log.error(msg);
throw new IllegalStateException(msg); throw new IllegalStateException(msg);
} }
@ -274,7 +274,7 @@ public class DeviceMgtAPIUtils {
ctx.getOSGiService(CertificateManagementService.class, null); ctx.getOSGiService(CertificateManagementService.class, null);
if (certificateManagementService == null) { if (certificateManagementService == null) {
String msg = "Certificate Management service not initialized."; String msg = "CertificateImpl Management service not initialized.";
log.error(msg); log.error(msg);
throw new IllegalStateException(msg); throw new IllegalStateException(msg);
} }
@ -299,7 +299,7 @@ public class DeviceMgtAPIUtils {
DeviceInformationManager deviceInformationManager = DeviceInformationManager deviceInformationManager =
(DeviceInformationManager) ctx.getOSGiService(DeviceInformationManager.class, null); (DeviceInformationManager) ctx.getOSGiService(DeviceInformationManager.class, null);
if (deviceInformationManager == null) { if (deviceInformationManager == null) {
String msg = "Device information Manager service has not initialized."; String msg = "DeviceImpl information Manager service has not initialized.";
log.error(msg); log.error(msg);
throw new IllegalStateException(msg); throw new IllegalStateException(msg);
} }
@ -313,7 +313,7 @@ public class DeviceMgtAPIUtils {
SearchManagerService searchManagerService = SearchManagerService searchManagerService =
(SearchManagerService) ctx.getOSGiService(SearchManagerService.class, null); (SearchManagerService) ctx.getOSGiService(SearchManagerService.class, null);
if (searchManagerService == null) { if (searchManagerService == null) {
String msg = "Device search manager service has not initialized."; String msg = "DeviceImpl search manager service has not initialized.";
log.error(msg); log.error(msg);
throw new IllegalStateException(msg); throw new IllegalStateException(msg);
} }

@ -33,7 +33,7 @@ import org.wso2.carbon.device.mgt.jaxrs.beans.android.WebApplication;
public class MDMAndroidOperationUtil { public class MDMAndroidOperationUtil {
/** /**
* This method is used to create Install Application operation. * This method is used to create Install Authentication operation.
* *
* @param application MobileApp application * @param application MobileApp application
* @return operation * @return operation
@ -76,7 +76,7 @@ public class MDMAndroidOperationUtil {
} }
/** /**
* This method is used to create Uninstall Application operation. * This method is used to create Uninstall Authentication operation.
* @param application MobileApp application * @param application MobileApp application
* @return operation * @return operation
* @throws MDMAPIException * @throws MDMAPIException

@ -35,7 +35,7 @@ import java.util.Properties;
public class MDMIOSOperationUtil { public class MDMIOSOperationUtil {
/** /**
* This method is used to create Install Application operation. * This method is used to create Install Authentication operation.
* *
* @param application MobileApp application * @param application MobileApp application
* @return operation * @return operation

@ -21,7 +21,7 @@ package org.wso2.carbon.device.mgt.jaxrs.beans;
import java.util.Properties; import java.util.Properties;
/** /**
* This class represents the generic mobile Application information * This class represents the generic mobile AuthenticationImpl information
* which is used by AppM. * which is used by AppM.
*/ */
public class MobileApp { public class MobileApp {

@ -53,11 +53,11 @@ public class Profile {
this.tenantId = tenantId; this.tenantId = tenantId;
} }
/* public List<Feature> getFeaturesList() { /* public List<FeatureImpl> getFeaturesList() {
return featuresList; return featuresList;
} }
public void setFeaturesList(List<Feature> featuresList) { public void setFeaturesList(List<FeatureImpl> featuresList) {
this.featuresList = featuresList; this.featuresList = featuresList;
}*/ }*/
@XmlElement @XmlElement

@ -24,7 +24,7 @@ import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException;
import java.io.Serializable; import java.io.Serializable;
/** /**
* This class represents the Appstore Application information. * This class represents the Appstore AuthenticationImpl information.
*/ */
public class AppStoreApplication implements Serializable { public class AppStoreApplication implements Serializable {

@ -24,7 +24,7 @@ import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException;
import java.io.Serializable; import java.io.Serializable;
/** /**
* This class represents the Enterprise Application information. * This class represents the Enterprise AuthenticationImpl information.
*/ */
public class EnterpriseApplication implements Serializable { public class EnterpriseApplication implements Serializable {

@ -24,7 +24,7 @@ import org.wso2.carbon.device.mgt.jaxrs.api.common.MDMAPIException;
import java.io.Serializable; import java.io.Serializable;
/** /**
* This class represents the Web Application information. * This class represents the Web AuthenticationImpl information.
*/ */
public class WebApplication implements Serializable { public class WebApplication implements Serializable {

@ -19,7 +19,7 @@
package org.wso2.carbon.device.mgt.jaxrs.util; package org.wso2.carbon.device.mgt.jaxrs.util;
/** /**
* Holds the constants used by Device Management Admin web application. * Holds the constants used by DeviceImpl Management Admin web application.
*/ */
public class Constants { public class Constants {

@ -163,23 +163,23 @@
</jaxrs:providers> </jaxrs:providers>
</jaxrs:server> </jaxrs:server>
--> -->
<bean id="operationServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.Operation"/> <bean id="operationServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.OperationImpl"/>
<bean id="deviceServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.Device"/> <bean id="deviceServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.DeviceImpl"/>
<bean id="groupServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.Group"/> <bean id="groupServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.GroupImpl"/>
<bean id="userServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.User"/> <bean id="userServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.UserImpl"/>
<bean id="roleServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.Role"/> <bean id="roleServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.RoleImpl"/>
<bean id="featureServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.Feature"/> <bean id="featureServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.FeatureImpl"/>
<bean id="configurationServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.Configuration"/> <bean id="configurationServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.ConfigurationImpl"/>
<bean id="notificationServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.DeviceNotification"/> <bean id="notificationServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.DeviceNotificationImpl"/>
<bean id="licenseServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.License"/> <bean id="licenseServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.LicenseImpl"/>
<bean id="certificateServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.Certificate"/> <bean id="certificateServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.CertificateImpl"/>
<bean id="informationServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.DeviceInformation"/> <bean id="informationServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.DeviceInformationImpl"/>
<bean id="searchingServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.DeviceSearch"/> <bean id="searchingServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.DeviceSearchImpl"/>
<!-- <!--
<bean id="authenticationServiceBean" class="Authentication"/> <bean id="authenticationServiceBean" class="AuthenticationImpl"/>
--> -->
<bean id="policyServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.Policy"/> <bean id="policyServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.PolicyImpl"/>
<bean id="profileServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.Profile"/> <bean id="profileServiceBean" class="org.wso2.carbon.device.mgt.jaxrs.api.impl.ProfileImpl"/>
<bean id="jsonProvider" class="org.wso2.carbon.device.mgt.jaxrs.common.GsonMessageBodyHandler"/> <bean id="jsonProvider" class="org.wso2.carbon.device.mgt.jaxrs.common.GsonMessageBodyHandler"/>
<bean id="errorHandler" class="org.wso2.carbon.device.mgt.jaxrs.api.common.ErrorHandler"/> <bean id="errorHandler" class="org.wso2.carbon.device.mgt.jaxrs.api.common.ErrorHandler"/>

@ -53,6 +53,7 @@
</plugin> </plugin>
</plugins> </plugins>
</build> </build>
<dependencies> <dependencies>
<dependency> <dependency>
<groupId>io.swagger</groupId> <groupId>io.swagger</groupId>
@ -60,4 +61,5 @@
<scope>provided</scope> <scope>provided</scope>
</dependency> </dependency>
</dependencies> </dependencies>
</project> </project>

@ -20,6 +20,7 @@ package org.wso2.carbon.device.mgt.common;
import javax.xml.bind.annotation.XmlElement; import javax.xml.bind.annotation.XmlElement;
import java.io.Serializable; import java.io.Serializable;
import java.util.List; import java.util.List;
import io.swagger.annotations.*;
public class Feature implements Serializable { public class Feature implements Serializable {

@ -73,7 +73,7 @@ public class JWTClientUtil {
private static final Log log = LogFactory.getLog(JWTClientUtil.class); private static final Log log = LogFactory.getLog(JWTClientUtil.class);
private static final String HTTPS_PROTOCOL = "https"; private static final String HTTPS_PROTOCOL = "https";
private static final String TENANT_JWT_CONFIG_LOCATION = "/jwt-config/jwt.properties"; private static final String TENANT_JWT_CONFIG_LOCATION = File.separator + "jwt-config" + File.separator + "jwt.properties";
private static final String JWT_CONFIG_FILE_NAME = "jwt.properties"; private static final String JWT_CONFIG_FILE_NAME = "jwt.properties";
private static final String SUPERTENANT_JWT_CONFIG_LOCATION = private static final String SUPERTENANT_JWT_CONFIG_LOCATION =
CarbonUtils.getEtcCarbonConfigDirPath() + File.separator + JWT_CONFIG_FILE_NAME; CarbonUtils.getEtcCarbonConfigDirPath() + File.separator + JWT_CONFIG_FILE_NAME;

@ -28,6 +28,7 @@ public class CertificateAuthenticator implements WebappAuthenticator {
private static final Log log = LogFactory.getLog(CertificateAuthenticator.class); private static final Log log = LogFactory.getLog(CertificateAuthenticator.class);
private static final String CERTIFICATE_AUTHENTICATOR = "CertificateAuth"; private static final String CERTIFICATE_AUTHENTICATOR = "CertificateAuth";
private static final String MUTUAL_AUTH_HEADER = "mutual-auth-header"; private static final String MUTUAL_AUTH_HEADER = "mutual-auth-header";
private static final String PROXY_MUTUAL_AUTH_HEADER = "proxy-mutual-auth-header";
private static final String CERTIFICATE_VERIFICATION_HEADER = "certificate-verification-header"; private static final String CERTIFICATE_VERIFICATION_HEADER = "certificate-verification-header";
private static final String CLIENT_CERTIFICATE_ATTRIBUTE = "javax.servlet.request.X509Certificate"; private static final String CLIENT_CERTIFICATE_ATTRIBUTE = "javax.servlet.request.X509Certificate";
@ -38,8 +39,8 @@ public class CertificateAuthenticator implements WebappAuthenticator {
@Override @Override
public boolean canHandle(Request request) { public boolean canHandle(Request request) {
if (request.getHeader(CERTIFICATE_VERIFICATION_HEADER) != null || request.getHeader(MUTUAL_AUTH_HEADER) != if (request.getHeader(CERTIFICATE_VERIFICATION_HEADER) != null || request.getHeader(MUTUAL_AUTH_HEADER) != null
null) { || request.getHeader(PROXY_MUTUAL_AUTH_HEADER) != null) {
return true; return true;
} }
return false; return false;
@ -56,35 +57,20 @@ public class CertificateAuthenticator implements WebappAuthenticator {
String certVerificationHeader = request.getContext().findParameter(CERTIFICATE_VERIFICATION_HEADER); String certVerificationHeader = request.getContext().findParameter(CERTIFICATE_VERIFICATION_HEADER);
try { try {
// When there is a load balancer terminating mutual SSL, it should pass this header along and
if (request.getHeader(MUTUAL_AUTH_HEADER) != null) { // as the value of this header, the client certificate subject dn should be passed.
if (request.getHeader(PROXY_MUTUAL_AUTH_HEADER) != null) {
CertificateResponse certificateResponse = AuthenticatorFrameworkDataHolder.getInstance().
getCertificateManagementService().verifySubjectDN(request.getHeader(PROXY_MUTUAL_AUTH_HEADER));
authenticationInfo = checkCertificateResponse(certificateResponse);
}
else if (request.getHeader(MUTUAL_AUTH_HEADER) != null) {
X509Certificate[] clientCertificate = (X509Certificate[]) request. X509Certificate[] clientCertificate = (X509Certificate[]) request.
getAttribute(CLIENT_CERTIFICATE_ATTRIBUTE); getAttribute(CLIENT_CERTIFICATE_ATTRIBUTE);
if (clientCertificate != null && clientCertificate[0] != null) { if (clientCertificate != null && clientCertificate[0] != null) {
CertificateResponse certificateResponse = AuthenticatorFrameworkDataHolder.getInstance(). CertificateResponse certificateResponse = AuthenticatorFrameworkDataHolder.getInstance().
getCertificateManagementService().verifyPEMSignature(clientCertificate[0]); getCertificateManagementService().verifyPEMSignature(clientCertificate[0]);
if (certificateResponse == null) { authenticationInfo = checkCertificateResponse(certificateResponse);
authenticationInfo.setStatus(Status.FAILURE);
authenticationInfo.setMessage("Certificate sent doesn't match any certificate in the store." +
" Unauthorized access attempt.");
} else if (certificateResponse.getCommonName() != null && !certificateResponse.getCommonName().
isEmpty()) {
authenticationInfo.setTenantId(certificateResponse.getTenantId());
authenticationInfo.setStatus(Status.CONTINUE);
authenticationInfo.setUsername(certificateResponse.getCommonName());
try {
authenticationInfo.setTenantDomain(Utils.
getTenantDomain(
certificateResponse.getTenantId()));
} catch (AuthenticationException e) {
authenticationInfo.setStatus(Status.FAILURE);
authenticationInfo.setMessage("Could not identify tenant domain.");
}
} else {
authenticationInfo.setStatus(Status.FAILURE);
authenticationInfo.setMessage("A matching certificate is found, " +
"but the serial number is missing in the database.");
}
} else { } else {
authenticationInfo.setStatus(Status.FAILURE); authenticationInfo.setStatus(Status.FAILURE);
@ -133,6 +119,33 @@ public class CertificateAuthenticator implements WebappAuthenticator {
return authenticationInfo; return authenticationInfo;
} }
private AuthenticationInfo checkCertificateResponse(CertificateResponse certificateResponse) {
AuthenticationInfo authenticationInfo = new AuthenticationInfo();
if (certificateResponse == null) {
authenticationInfo.setStatus(Status.FAILURE);
authenticationInfo.setMessage("Certificate sent doesn't match any certificate in the store." +
" Unauthorized access attempt.");
} else if (certificateResponse.getCommonName() != null && !certificateResponse.getCommonName().
isEmpty()) {
authenticationInfo.setTenantId(certificateResponse.getTenantId());
authenticationInfo.setStatus(Status.CONTINUE);
authenticationInfo.setUsername(certificateResponse.getCommonName());
try {
authenticationInfo.setTenantDomain(Utils.
getTenantDomain(
certificateResponse.getTenantId()));
} catch (AuthenticationException e) {
authenticationInfo.setStatus(Status.FAILURE);
authenticationInfo.setMessage("Could not identify tenant domain.");
}
} else {
authenticationInfo.setStatus(Status.FAILURE);
authenticationInfo.setMessage("A matching certificate is found, " +
"but the serial number is missing in the database.");
}
return authenticationInfo;
}
@Override @Override
public String getName() { public String getName() {
return CERTIFICATE_AUTHENTICATOR; return CERTIFICATE_AUTHENTICATOR;

@ -515,6 +515,7 @@ CREATE TABLE IF NOT EXISTS DM_DEVICE_GROUP_POLICY (
CREATE VIEW DEVICES_VIEW_1 AS CREATE VIEW DEVICES_VIEW_1 AS
SELECT SELECT
DEVICE_INFO.DEVICE_ID, DEVICE_INFO.DEVICE_ID,
DEVICE_INFO.DEVICE_IDENTIFICATION,
DEVICE_INFO.PLATFORM, DEVICE_INFO.PLATFORM,
DEVICE_INFO.OWNERSHIP, DEVICE_INFO.OWNERSHIP,
DEVICE_INFO.CONNECTIVITY_STATUS, DEVICE_INFO.CONNECTIVITY_STATUS,
@ -524,6 +525,7 @@ DEVICE_INFO.TENANT_ID
FROM FROM
(SELECT (SELECT
DM_DEVICE.ID AS DEVICE_ID, DM_DEVICE.ID AS DEVICE_ID,
DM_DEVICE.DEVICE_IDENTIFICATION,
DM_DEVICE_TYPE.NAME AS PLATFORM, DM_DEVICE_TYPE.NAME AS PLATFORM,
DM_ENROLMENT.OWNERSHIP, DM_ENROLMENT.OWNERSHIP,
DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS, DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS,
@ -542,6 +544,7 @@ ORDER BY DEVICE_INFO.DEVICE_ID;
CREATE VIEW DEVICES_VIEW_2 AS CREATE VIEW DEVICES_VIEW_2 AS
SELECT SELECT
DM_DEVICE.ID AS DEVICE_ID, DM_DEVICE.ID AS DEVICE_ID,
DM_DEVICE.DEVICE_IDENTIFICATION,
DM_DEVICE_DETAIL.DEVICE_MODEL, DM_DEVICE_DETAIL.DEVICE_MODEL,
DM_DEVICE_DETAIL.VENDOR, DM_DEVICE_DETAIL.VENDOR,
DM_DEVICE_DETAIL.OS_VERSION, DM_DEVICE_DETAIL.OS_VERSION,

@ -507,6 +507,7 @@ CREATE INDEX FK_DM_DEVICE_DETAILS_DEVICE_idx ON DM_DEVICE_DETAIL (DEVICE_ID ASC)
CREATE VIEW DEVICES_VIEW_1 AS CREATE VIEW DEVICES_VIEW_1 AS
SELECT TOP 100 PERCENT SELECT TOP 100 PERCENT
DEVICE_INFO.DEVICE_ID, DEVICE_INFO.DEVICE_ID,
DEVICE_INFO.DEVICE_IDENTIFICATION,
DEVICE_INFO.PLATFORM, DEVICE_INFO.PLATFORM,
DEVICE_INFO.OWNERSHIP, DEVICE_INFO.OWNERSHIP,
DEVICE_INFO.CONNECTIVITY_STATUS, DEVICE_INFO.CONNECTIVITY_STATUS,
@ -517,6 +518,7 @@ DEVICE_INFO.TENANT_ID
FROM FROM
(SELECT (SELECT
DM_DEVICE.ID AS DEVICE_ID, DM_DEVICE.ID AS DEVICE_ID,
DM_DEVICE.DEVICE_IDENTIFICATION,
DM_DEVICE_TYPE.NAME AS PLATFORM, DM_DEVICE_TYPE.NAME AS PLATFORM,
DM_ENROLMENT.OWNERSHIP, DM_ENROLMENT.OWNERSHIP,
DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS, DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS,
@ -537,6 +539,7 @@ GO
CREATE VIEW DEVICES_VIEW_2 AS CREATE VIEW DEVICES_VIEW_2 AS
SELECT TOP 100 PERCENT SELECT TOP 100 PERCENT
DM_DEVICE.ID AS DEVICE_ID, DM_DEVICE.ID AS DEVICE_ID,
DM_DEVICE.DEVICE_IDENTIFICATION,
DM_DEVICE_DETAIL.DEVICE_MODEL, DM_DEVICE_DETAIL.DEVICE_MODEL,
DM_DEVICE_DETAIL.VENDOR, DM_DEVICE_DETAIL.VENDOR,
DM_DEVICE_DETAIL.OS_VERSION, DM_DEVICE_DETAIL.OS_VERSION,

@ -527,6 +527,7 @@ ENGINE = InnoDB;
CREATE VIEW DEVICE_INFO_VIEW AS CREATE VIEW DEVICE_INFO_VIEW AS
SELECT SELECT
DM_DEVICE.ID AS DEVICE_ID, DM_DEVICE.ID AS DEVICE_ID,
DM_DEVICE.DEVICE_IDENTIFICATION,
DM_DEVICE_TYPE.NAME AS PLATFORM, DM_DEVICE_TYPE.NAME AS PLATFORM,
DM_ENROLMENT.OWNERSHIP, DM_ENROLMENT.OWNERSHIP,
DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS, DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS,
@ -544,6 +545,7 @@ FROM DM_POLICY_COMPLIANCE_STATUS;
CREATE VIEW DEVICES_VIEW_1 AS CREATE VIEW DEVICES_VIEW_1 AS
SELECT SELECT
DEVICE_INFO_VIEW.DEVICE_ID, DEVICE_INFO_VIEW.DEVICE_ID,
DEVICE_INFO_VIEW.DEVICE_IDENTIFICATION,
DEVICE_INFO_VIEW.PLATFORM, DEVICE_INFO_VIEW.PLATFORM,
DEVICE_INFO_VIEW.OWNERSHIP, DEVICE_INFO_VIEW.OWNERSHIP,
DEVICE_INFO_VIEW.CONNECTIVITY_STATUS, DEVICE_INFO_VIEW.CONNECTIVITY_STATUS,
@ -560,6 +562,7 @@ ORDER BY DEVICE_INFO_VIEW.DEVICE_ID;
CREATE VIEW DEVICES_VIEW_2 AS CREATE VIEW DEVICES_VIEW_2 AS
SELECT SELECT
DM_DEVICE.ID AS DEVICE_ID, DM_DEVICE.ID AS DEVICE_ID,
DM_DEVICE.DEVICE_IDENTIFICATION,
DM_DEVICE_DETAIL.DEVICE_MODEL, DM_DEVICE_DETAIL.DEVICE_MODEL,
DM_DEVICE_DETAIL.VENDOR, DM_DEVICE_DETAIL.VENDOR,
DM_DEVICE_DETAIL.OS_VERSION, DM_DEVICE_DETAIL.OS_VERSION,

@ -853,6 +853,7 @@ WHEN (NEW.ID IS NULL)
CREATE VIEW DEVICES_VIEW_1 AS CREATE VIEW DEVICES_VIEW_1 AS
SELECT SELECT
DEVICE_INFO.DEVICE_ID, DEVICE_INFO.DEVICE_ID,
DEVICE_INFO.DEVICE_IDENTIFICATION,
DEVICE_INFO.PLATFORM, DEVICE_INFO.PLATFORM,
DEVICE_INFO.OWNERSHIP, DEVICE_INFO.OWNERSHIP,
DEVICE_INFO.CONNECTIVITY_STATUS, DEVICE_INFO.CONNECTIVITY_STATUS,
@ -862,6 +863,7 @@ DEVICE_INFO.TENANT_ID
FROM FROM
(SELECT (SELECT
DM_DEVICE.ID AS DEVICE_ID, DM_DEVICE.ID AS DEVICE_ID,
DM_DEVICE.DEVICE_IDENTIFICATION,
DM_DEVICE_TYPE.NAME AS PLATFORM, DM_DEVICE_TYPE.NAME AS PLATFORM,
DM_ENROLMENT.OWNERSHIP, DM_ENROLMENT.OWNERSHIP,
DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS, DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS,
@ -880,6 +882,7 @@ ORDER BY DEVICE_INFO.DEVICE_ID;
CREATE VIEW DEVICES_VIEW_2 AS CREATE VIEW DEVICES_VIEW_2 AS
SELECT SELECT
DM_DEVICE.ID AS DEVICE_ID, DM_DEVICE.ID AS DEVICE_ID,
DM_DEVICE.DEVICE_IDENTIFICATION,
DM_DEVICE_DETAIL.DEVICE_MODEL, DM_DEVICE_DETAIL.DEVICE_MODEL,
DM_DEVICE_DETAIL.VENDOR, DM_DEVICE_DETAIL.VENDOR,
DM_DEVICE_DETAIL.OS_VERSION, DM_DEVICE_DETAIL.OS_VERSION,

@ -434,6 +434,7 @@ CREATE TABLE IF NOT EXISTS DM_DEVICE_DETAIL (
CREATE VIEW DEVICES_VIEW_1 AS CREATE VIEW DEVICES_VIEW_1 AS
SELECT SELECT
DEVICE_INFO.DEVICE_ID, DEVICE_INFO.DEVICE_ID,
DEVICE_INFO.DEVICE_IDENTIFICATION,
DEVICE_INFO.PLATFORM, DEVICE_INFO.PLATFORM,
DEVICE_INFO.OWNERSHIP, DEVICE_INFO.OWNERSHIP,
DEVICE_INFO.CONNECTIVITY_STATUS, DEVICE_INFO.CONNECTIVITY_STATUS,
@ -443,6 +444,7 @@ DEVICE_INFO.TENANT_ID
FROM FROM
(SELECT (SELECT
DM_DEVICE.ID AS DEVICE_ID, DM_DEVICE.ID AS DEVICE_ID,
DM_DEVICE.DEVICE_IDENTIFICATION,
DM_DEVICE_TYPE.NAME AS PLATFORM, DM_DEVICE_TYPE.NAME AS PLATFORM,
DM_ENROLMENT.OWNERSHIP, DM_ENROLMENT.OWNERSHIP,
DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS, DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS,
@ -461,6 +463,7 @@ ORDER BY DEVICE_INFO.DEVICE_ID;
CREATE VIEW DEVICES_VIEW_2 AS CREATE VIEW DEVICES_VIEW_2 AS
SELECT SELECT
DM_DEVICE.ID AS DEVICE_ID, DM_DEVICE.ID AS DEVICE_ID,
DM_DEVICE.DEVICE_IDENTIFICATION,
DM_DEVICE_DETAIL.DEVICE_MODEL, DM_DEVICE_DETAIL.DEVICE_MODEL,
DM_DEVICE_DETAIL.VENDOR, DM_DEVICE_DETAIL.VENDOR,
DM_DEVICE_DETAIL.OS_VERSION, DM_DEVICE_DETAIL.OS_VERSION,

@ -19,7 +19,7 @@
#issuer of the JWT #issuer of the JWT
iss=CDMF_DEFAULT_IDP iss=CDMF_DEFAULT_IDP
TokenEndpoint=https://${server.host}:${mgt.transport.https.port}/oauth2/token TokenEndpoint=https://localhost:${carbon.https.port}/oauth2/token
#audience of JWT claim #audience of JWT claim
#comma seperated values #comma seperated values

Loading…
Cancel
Save