|
|
|
|
@ -21,19 +21,18 @@ import org.apache.commons.lang.StringUtils;
|
|
|
|
|
import org.apache.commons.logging.Log;
|
|
|
|
|
import org.apache.commons.logging.LogFactory;
|
|
|
|
|
import org.wso2.carbon.context.PrivilegedCarbonContext;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.AppOperation;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.ApplicationInstallResponse;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.ApplicationType;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.DeviceTypes;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.SubAction;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.SubsciptionType;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.SubscribingDeviceIdHolder;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.dto.ApplicationDTO;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.ApplicationInstallResponseTmp;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.dto.DeviceSubscriptionDTO;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.exception.ApplicationManagementException;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.exception.DBConnectionException;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.exception.LifecycleManagementException;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.exception.TransactionManagementException;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.services.ApplicationManager;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.common.services.SubscriptionManager;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.core.dao.ApplicationDAO;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.core.dao.SubscriptionDAO;
|
|
|
|
|
@ -49,22 +48,23 @@ import org.wso2.carbon.device.application.mgt.core.util.ConnectionManagerUtil;
|
|
|
|
|
import org.wso2.carbon.device.application.mgt.core.util.HelperUtil;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.Device;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.InvalidDeviceException;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroup;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.app.mgt.MobileApp;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.exceptions.DeviceManagementException;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.exceptions.InvalidDeviceException;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.exceptions.UnknownApplicationTypeException;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.group.mgt.GroupManagementException;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.operation.mgt.Activity;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.operation.mgt.ActivityStatus;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.operation.mgt.Operation;
|
|
|
|
|
import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManagementException;
|
|
|
|
|
import org.wso2.carbon.device.mgt.core.dto.DeviceType;
|
|
|
|
|
import org.wso2.carbon.device.mgt.core.operation.mgt.ProfileOperation;
|
|
|
|
|
import org.wso2.carbon.device.mgt.core.operation.mgt.util.DeviceIDHolder;
|
|
|
|
|
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
|
|
|
|
|
import org.wso2.carbon.device.mgt.core.service.GroupManagementProviderService;
|
|
|
|
|
import org.wso2.carbon.device.mgt.core.util.DeviceManagerUtil;
|
|
|
|
|
import org.wso2.carbon.device.mgt.core.util.MDMAndroidOperationUtil;
|
|
|
|
|
import org.wso2.carbon.device.mgt.core.util.MDMIOSOperationUtil;
|
|
|
|
|
|
|
|
|
|
import java.util.ArrayList;
|
|
|
|
|
import java.util.Arrays;
|
|
|
|
|
import java.util.HashMap;
|
|
|
|
|
import java.util.List;
|
|
|
|
|
import java.util.Map;
|
|
|
|
|
@ -76,7 +76,6 @@ import java.util.stream.Collectors;
|
|
|
|
|
public class SubscriptionManagerImpl implements SubscriptionManager {
|
|
|
|
|
|
|
|
|
|
private static final Log log = LogFactory.getLog(SubscriptionManagerImpl.class);
|
|
|
|
|
private static final String INSTALL_APPLICATION = "INSTALL_APPLICATION";
|
|
|
|
|
private SubscriptionDAO subscriptionDAO;
|
|
|
|
|
private ApplicationDAO applicationDAO;
|
|
|
|
|
private LifecycleStateManager lifecycleStateManager;
|
|
|
|
|
@ -87,115 +86,103 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
|
|
|
|
|
this.applicationDAO = ApplicationManagementDAOFactory.getApplicationDAO();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@Override public ApplicationInstallResponse installApplicationForDevices(String applicationUUID,
|
|
|
|
|
List<DeviceIdentifier> deviceIdentifiers) throws ApplicationManagementException {
|
|
|
|
|
if (log.isDebugEnabled()) {
|
|
|
|
|
log.debug("Install application which has UUID: " + applicationUUID + " to " + deviceIdentifiers.size()
|
|
|
|
|
+ "devices.");
|
|
|
|
|
}
|
|
|
|
|
if (deviceIdentifiers.isEmpty()){
|
|
|
|
|
String msg = "In order to install application release which has UUID " + applicationUUID + ", you should "
|
|
|
|
|
+ "provide list of device identifiers. But found an empty list of identifiers.";
|
|
|
|
|
log.error(msg);
|
|
|
|
|
throw new BadRequestException(msg);
|
|
|
|
|
}
|
|
|
|
|
DeviceManagementProviderService deviceManagementProviderService = HelperUtil
|
|
|
|
|
.getDeviceManagementProviderService();
|
|
|
|
|
ApplicationDTO applicationDTO = getApplicationDTO(applicationUUID);
|
|
|
|
|
DeviceIDHolder filteredDeviceHolder = filterDeviceIdentifiers(applicationDTO, deviceIdentifiers);
|
|
|
|
|
List<DeviceIdentifier> errorDeviceIdentifiers = filteredDeviceHolder.getErrorDeviceIdList();
|
|
|
|
|
List<Device> filteredDeviceObjs = new ArrayList<>();
|
|
|
|
|
|
|
|
|
|
//getting device objects by using device identifiers
|
|
|
|
|
for (DeviceIdentifier deviceIdentifier : filteredDeviceHolder.getValidDeviceIDList()) {
|
|
|
|
|
try {
|
|
|
|
|
Device device = deviceManagementProviderService.getDevice(deviceIdentifier, false);
|
|
|
|
|
if (device == null) {
|
|
|
|
|
String msg = "Couldn't found an device for device identifier " + deviceIdentifier.getId()
|
|
|
|
|
+ " and device type: " + deviceIdentifier.getType();
|
|
|
|
|
log.warn(msg);
|
|
|
|
|
errorDeviceIdentifiers.add(deviceIdentifier);
|
|
|
|
|
} else {
|
|
|
|
|
filteredDeviceObjs.add(device);
|
|
|
|
|
}
|
|
|
|
|
} catch (DeviceManagementException e) {
|
|
|
|
|
String msg = "Error occurred when getting device data for device identifier " + deviceIdentifier.getId()
|
|
|
|
|
+ " and device type " + deviceIdentifier.getType();
|
|
|
|
|
log.warn(msg);
|
|
|
|
|
errorDeviceIdentifiers.add(deviceIdentifier);
|
|
|
|
|
throw new ApplicationManagementException(msg, e);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!ApplicationType.WEB_CLIP.toString().equals(applicationDTO.getType())) {
|
|
|
|
|
DeviceType deviceType = APIUtil.getDeviceTypeData(applicationDTO.getDeviceTypeId());
|
|
|
|
|
String deviceTypeName = deviceType.getName();
|
|
|
|
|
ApplicationInstallResponse applicationInstallResponse = installToDevices(deviceTypeName, filteredDeviceObjs,
|
|
|
|
|
applicationDTO, SubsciptionType.DEVICE.toString(), null);
|
|
|
|
|
applicationInstallResponse.setErrorDevices(errorDeviceIdentifiers);
|
|
|
|
|
return applicationInstallResponse;
|
|
|
|
|
} else {
|
|
|
|
|
//todo improve thos
|
|
|
|
|
ApplicationInstallResponse applicationInstallResponse = installToDevices(null, filteredDeviceObjs,
|
|
|
|
|
applicationDTO, SubsciptionType.DEVICE.toString(), null);
|
|
|
|
|
applicationInstallResponse.setErrorDevices(errorDeviceIdentifiers);
|
|
|
|
|
return applicationInstallResponse;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@Override
|
|
|
|
|
public ApplicationInstallResponse addBulkApInstallation(String applicationUUID, List<String> subscriberList,
|
|
|
|
|
String subType) throws ApplicationManagementException {
|
|
|
|
|
public <T> ApplicationInstallResponse performBulkAppInstallation(String applicationUUID, List<T> params,
|
|
|
|
|
String subType, String action) throws ApplicationManagementException {
|
|
|
|
|
if (log.isDebugEnabled()) {
|
|
|
|
|
log.debug("Install application release which has UUID " + applicationUUID + " to " + subscriberList.size()
|
|
|
|
|
log.debug("Install application release which has UUID " + applicationUUID + " to " + params.size()
|
|
|
|
|
+ " users.");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
if (subscriberList.isEmpty()) {
|
|
|
|
|
String msg = "In order to install application release which has UUID " + applicationUUID + ", you shou"
|
|
|
|
|
+ "ld provide list of subscribers. But found an empty list of users.";
|
|
|
|
|
if (params.isEmpty()) {
|
|
|
|
|
String msg = "In order to install application release which has UUID " + applicationUUID + ", you should"
|
|
|
|
|
+ " provide list of subscribers. But found an empty list of users.";
|
|
|
|
|
log.error(msg);
|
|
|
|
|
throw new BadRequestException(msg);
|
|
|
|
|
}
|
|
|
|
|
if (SubsciptionType.USER.toString().equals(subType) && !SubsciptionType.ROLE.toString().equals(subType)
|
|
|
|
|
&& SubsciptionType.GROUP.toString().equals(subType)) {
|
|
|
|
|
|
|
|
|
|
boolean isValidSubType = Arrays.stream(SubsciptionType.values())
|
|
|
|
|
.anyMatch(sub -> sub.name().equalsIgnoreCase(subType));
|
|
|
|
|
if (!isValidSubType) {
|
|
|
|
|
String msg = "Found invalid subscription type to install application release witch has UUID: "
|
|
|
|
|
+ applicationUUID + ". Subscription type is " + subType;
|
|
|
|
|
log.error(msg);
|
|
|
|
|
throw new BadRequestException(msg);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ApplicationDTO applicationDTO = getApplicationDTO(applicationUUID);
|
|
|
|
|
DeviceManagementProviderService deviceManagementProviderService = HelperUtil
|
|
|
|
|
.getDeviceManagementProviderService();
|
|
|
|
|
GroupManagementProviderService groupManagementProviderService = HelperUtil
|
|
|
|
|
.getGroupManagementProviderService();
|
|
|
|
|
List<Device> filteredDevices = new ArrayList<>();
|
|
|
|
|
List<Device> subscriberDevices = new ArrayList<>();
|
|
|
|
|
for (String subscriber : subscriberList) {
|
|
|
|
|
if (SubsciptionType.USER.toString().equals(subType)) {
|
|
|
|
|
subscriberDevices.addAll(deviceManagementProviderService.getDevicesOfUser(subscriber));
|
|
|
|
|
} else if (SubsciptionType.ROLE.toString().equals(subType)) {
|
|
|
|
|
subscriberDevices.addAll(deviceManagementProviderService.getAllDevicesOfRole(subscriber));
|
|
|
|
|
} else if (SubsciptionType.GROUP.toString().equals(subType)) {
|
|
|
|
|
subscriberDevices.addAll(groupManagementProviderService.getAllDevicesOfGroup(subscriber));
|
|
|
|
|
List<Device> devices = new ArrayList<>();
|
|
|
|
|
List<String> subscribers = new ArrayList<>();
|
|
|
|
|
List<DeviceIdentifier> errorDeviceIdentifiers = new ArrayList<>();
|
|
|
|
|
ApplicationInstallResponse applicationInstallResponse;
|
|
|
|
|
|
|
|
|
|
ApplicationDTO applicationDTO = getApplicationDTO(applicationUUID);
|
|
|
|
|
if (SubsciptionType.DEVICE.toString().equals(subType)) {
|
|
|
|
|
for (T param : params) {
|
|
|
|
|
DeviceIdentifier deviceIdentifier = (DeviceIdentifier) param;
|
|
|
|
|
if (StringUtils.isEmpty(deviceIdentifier.getId()) || StringUtils
|
|
|
|
|
.isEmpty(deviceIdentifier.getType())) {
|
|
|
|
|
log.warn("Found a device identifier which has either empty identity of the device or empty"
|
|
|
|
|
+ " device type. Hence ignoring the device identifier. ");
|
|
|
|
|
}
|
|
|
|
|
if (!ApplicationType.WEB_CLIP.toString().equals(applicationDTO.getType())) {
|
|
|
|
|
DeviceType deviceType = APIUtil.getDeviceTypeData(applicationDTO.getDeviceTypeId());
|
|
|
|
|
if (!deviceType.getName().equals(deviceIdentifier.getType())) {
|
|
|
|
|
String msg =
|
|
|
|
|
"Found a device identifier which is not matched with the application device Type. "
|
|
|
|
|
+ "Application device type is " + deviceType.getName() + " and the "
|
|
|
|
|
+ "identifier of which has a " + "different device type is "
|
|
|
|
|
+ deviceIdentifier.getId();
|
|
|
|
|
log.warn(msg);
|
|
|
|
|
errorDeviceIdentifiers.add(deviceIdentifier);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
devices.add(deviceManagementProviderService.getDevice(deviceIdentifier, false));
|
|
|
|
|
}
|
|
|
|
|
} else if (SubsciptionType.USER.toString().equals(subType)) {
|
|
|
|
|
for (T param : params) {
|
|
|
|
|
String username = (String) param;
|
|
|
|
|
subscribers.add(username);
|
|
|
|
|
devices.addAll(deviceManagementProviderService.getDevicesOfUser(username));
|
|
|
|
|
}
|
|
|
|
|
} else if (SubsciptionType.ROLE.toString().equals(subType)) {
|
|
|
|
|
for (T param : params) {
|
|
|
|
|
String roleName = (String) param;
|
|
|
|
|
subscribers.add(roleName);
|
|
|
|
|
devices.addAll(deviceManagementProviderService.getAllDevicesOfRole(roleName));
|
|
|
|
|
}
|
|
|
|
|
} else if (SubsciptionType.GROUP.toString().equals(subType)) {
|
|
|
|
|
for (T param : params) {
|
|
|
|
|
String groupName = (String) param;
|
|
|
|
|
subscribers.add(groupName);
|
|
|
|
|
devices.addAll(groupManagementProviderService.getAllDevicesOfGroup(groupName));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!ApplicationType.WEB_CLIP.toString().equals(applicationDTO.getType())) {
|
|
|
|
|
DeviceType deviceType = APIUtil.getDeviceTypeData(applicationDTO.getDeviceTypeId());
|
|
|
|
|
String deviceTypeName = deviceType.getName();
|
|
|
|
|
for (Device device : subscriberDevices) {
|
|
|
|
|
for (Device device : devices) {
|
|
|
|
|
if (deviceTypeName.equals(device.getType())) {
|
|
|
|
|
filteredDevices.add(device);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return installToDevices(deviceTypeName, filteredDevices, applicationDTO, subType, subscriberList);
|
|
|
|
|
applicationInstallResponse = performActionOnDevices(deviceTypeName, filteredDevices, applicationDTO,
|
|
|
|
|
subType, subscribers, action);
|
|
|
|
|
|
|
|
|
|
//todo add db insert to here
|
|
|
|
|
} else {
|
|
|
|
|
//todo improve this
|
|
|
|
|
return installToDevices(null, subscriberDevices, applicationDTO, subType, subscriberList);
|
|
|
|
|
applicationInstallResponse = performActionOnDevices(null, devices, applicationDTO, subType,
|
|
|
|
|
subscribers, action);
|
|
|
|
|
//todo add db insert to here
|
|
|
|
|
}
|
|
|
|
|
applicationInstallResponse.setErrorDevices(errorDeviceIdentifiers);
|
|
|
|
|
return applicationInstallResponse;
|
|
|
|
|
} catch (DeviceManagementException e) {
|
|
|
|
|
String msg = "Error occurred while getting devices of given users or given roles.";
|
|
|
|
|
log.error(msg);
|
|
|
|
|
@ -207,51 +194,98 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private ApplicationInstallResponse installToDevices(String deviceType, List<Device> devices,
|
|
|
|
|
ApplicationDTO applicationDTO, String subType, List<String> subscribers)
|
|
|
|
|
private ApplicationInstallResponse performActionOnDevices(String deviceType, List<Device> devices,
|
|
|
|
|
ApplicationDTO applicationDTO, String subType, List<String> subscribers, String action)
|
|
|
|
|
throws ApplicationManagementException {
|
|
|
|
|
|
|
|
|
|
SubscribingDeviceIdHolder subscribingDeviceIdHolder = getSubscribingDeviceIdHolder(devices);
|
|
|
|
|
if (subscribingDeviceIdHolder.getCompatibleDevices().isEmpty()) {
|
|
|
|
|
List<Activity> activityList = new ArrayList<>();
|
|
|
|
|
List<DeviceIdentifier> deviceIdentifiers = new ArrayList<>();
|
|
|
|
|
List<DeviceIdentifier> ignoredDeviceIdentifiers = new ArrayList<>();
|
|
|
|
|
Map<String, List<DeviceIdentifier>> deviceIdentifierMap = new HashMap<>();
|
|
|
|
|
|
|
|
|
|
if (SubAction.INSTALL.toString().equalsIgnoreCase(action)) {
|
|
|
|
|
deviceIdentifiers = new ArrayList<>(subscribingDeviceIdHolder.getSubscribableDevices().keySet());
|
|
|
|
|
ignoredDeviceIdentifiers = new ArrayList<>(subscribingDeviceIdHolder.getSubscribedDevices().keySet());
|
|
|
|
|
|
|
|
|
|
if (deviceIdentifiers.isEmpty()) {
|
|
|
|
|
ApplicationInstallResponse applicationInstallResponse = new ApplicationInstallResponse();
|
|
|
|
|
applicationInstallResponse.setIgnoredDeviceIdentifiers(ignoredDeviceIdentifiers);
|
|
|
|
|
return applicationInstallResponse;
|
|
|
|
|
}
|
|
|
|
|
} else if (SubAction.UNINSTALL.toString().equalsIgnoreCase(action)) {
|
|
|
|
|
deviceIdentifiers = new ArrayList<>(subscribingDeviceIdHolder.getSubscribedDevices().keySet());
|
|
|
|
|
ignoredDeviceIdentifiers = new ArrayList<>(subscribingDeviceIdHolder.getSubscribableDevices().keySet());
|
|
|
|
|
if (deviceIdentifiers.isEmpty()) {
|
|
|
|
|
ApplicationInstallResponse applicationInstallResponse = new ApplicationInstallResponse();
|
|
|
|
|
applicationInstallResponse.setIgnoredDeviceIdentifiers(ignoredDeviceIdentifiers);
|
|
|
|
|
return applicationInstallResponse;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (deviceType == null) {
|
|
|
|
|
for (DeviceIdentifier identifier : deviceIdentifiers) {
|
|
|
|
|
List<DeviceIdentifier> identifiers;
|
|
|
|
|
if (!deviceIdentifierMap.containsKey(identifier.getType())) {
|
|
|
|
|
identifiers = new ArrayList<>();
|
|
|
|
|
identifiers.add(identifier);
|
|
|
|
|
deviceIdentifierMap.put(identifier.getType(), identifiers);
|
|
|
|
|
} else {
|
|
|
|
|
identifiers = deviceIdentifierMap.get(identifier.getType());
|
|
|
|
|
identifiers.add(identifier);
|
|
|
|
|
deviceIdentifierMap.put(identifier.getType(), identifiers);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (Map.Entry<String, List<DeviceIdentifier>> entry : deviceIdentifierMap.entrySet()) {
|
|
|
|
|
Activity activity = addAppInstallOperationToDevices(applicationDTO,
|
|
|
|
|
new ArrayList<>(entry.getValue()), entry.getKey());
|
|
|
|
|
activityList.add(activity);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ApplicationInstallResponse applicationInstallResponse = new ApplicationInstallResponse();
|
|
|
|
|
applicationInstallResponse.setAlreadyInstalledDevices(subscribingDeviceIdHolder.getInstalledDevices());
|
|
|
|
|
applicationInstallResponse.setActivities(activityList);
|
|
|
|
|
applicationInstallResponse.setIgnoredDeviceIdentifiers(ignoredDeviceIdentifiers);
|
|
|
|
|
return applicationInstallResponse;
|
|
|
|
|
}
|
|
|
|
|
Activity activity = addAppInstallOperationToDevices(applicationDTO,
|
|
|
|
|
new ArrayList<>(subscribingDeviceIdHolder.getCompatibleDevices().keySet()), deviceType);
|
|
|
|
|
|
|
|
|
|
//todo consider action
|
|
|
|
|
|
|
|
|
|
Activity activity = addAppInstallOperationToDevices(applicationDTO, deviceIdentifiers, deviceType);
|
|
|
|
|
activityList.add(activity);
|
|
|
|
|
ApplicationInstallResponse applicationInstallResponse = new ApplicationInstallResponse();
|
|
|
|
|
applicationInstallResponse.setActivity(activity);
|
|
|
|
|
applicationInstallResponse.setAlreadyInstalledDevices(subscribingDeviceIdHolder.getInstalledDevices());
|
|
|
|
|
applicationInstallResponse.setActivities(activityList);
|
|
|
|
|
applicationInstallResponse.setIgnoredDeviceIdentifiers(ignoredDeviceIdentifiers);
|
|
|
|
|
|
|
|
|
|
addSubscriptions(applicationDTO.getApplicationReleaseDTOs().get(0).getId(), activity,
|
|
|
|
|
subscribingDeviceIdHolder.getCompatibleDevices(),
|
|
|
|
|
new ArrayList<>(subscribingDeviceIdHolder.getDeviceSubscriptions().keySet()), subscribers, subType);
|
|
|
|
|
//todo
|
|
|
|
|
addSubscriptions(applicationDTO.getApplicationReleaseDTOs().get(0).getId(), activity, subscribingDeviceIdHolder,
|
|
|
|
|
subscribers, subType, action);
|
|
|
|
|
return applicationInstallResponse;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private SubscribingDeviceIdHolder getSubscribingDeviceIdHolder(List<Device> devices)
|
|
|
|
|
throws ApplicationManagementException {
|
|
|
|
|
List<DeviceIdentifier> installedDevices = new ArrayList<>();
|
|
|
|
|
Map<DeviceIdentifier, Integer> compatibleDevices = new HashMap<>();
|
|
|
|
|
Map<DeviceIdentifier, Integer> subscribedDevices = new HashMap<>();
|
|
|
|
|
Map<DeviceIdentifier, Integer> subscribableDevices = new HashMap<>();
|
|
|
|
|
|
|
|
|
|
List<Integer> filteredDeviceIds = devices.stream().map(Device::getId).collect(Collectors.toList());
|
|
|
|
|
//get device subscriptions for given device id list.
|
|
|
|
|
Map<Integer, DeviceSubscriptionDTO> deviceSubscriptions = getDeviceSubscriptions(filteredDeviceIds);
|
|
|
|
|
for (Device device : devices) {
|
|
|
|
|
DeviceIdentifier deviceIdentifier = new DeviceIdentifier(device.getDeviceIdentifier(), device.getType());
|
|
|
|
|
DeviceSubscriptionDTO deviceSubscriptionDTO = deviceSubscriptions.get(device.getId());
|
|
|
|
|
if (deviceSubscriptionDTO != null && !deviceSubscriptionDTO.isUnsubscribed() && Operation.Status.COMPLETED
|
|
|
|
|
.toString().equals(deviceSubscriptionDTO.getStatus())) {
|
|
|
|
|
installedDevices.add(deviceIdentifier);
|
|
|
|
|
subscribedDevices.put(deviceIdentifier, device.getId());
|
|
|
|
|
} else {
|
|
|
|
|
compatibleDevices.put(deviceIdentifier, device.getId());
|
|
|
|
|
subscribableDevices.put(deviceIdentifier, device.getId());
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
SubscribingDeviceIdHolder subscribingDeviceIdHolder = new SubscribingDeviceIdHolder();
|
|
|
|
|
subscribingDeviceIdHolder.setCompatibleDevices(compatibleDevices);
|
|
|
|
|
subscribingDeviceIdHolder.setInstalledDevices(installedDevices);
|
|
|
|
|
subscribingDeviceIdHolder.setDeviceSubscriptions(deviceSubscriptions);
|
|
|
|
|
subscribingDeviceIdHolder.setSubscribableDevices(subscribableDevices);
|
|
|
|
|
subscribingDeviceIdHolder.setSubscribedDevices(subscribedDevices);
|
|
|
|
|
// subscribingDeviceIdHolder.setDeviceSubscriptions(deviceSubscriptions);
|
|
|
|
|
return subscribingDeviceIdHolder;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@ -290,54 +324,10 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private DeviceIDHolder filterDeviceIdentifiers(ApplicationDTO applicationDTO,
|
|
|
|
|
List<DeviceIdentifier> deviceIdentifiers) throws ApplicationManagementException {
|
|
|
|
|
List<DeviceIdentifier> errorDeviceIdList = new ArrayList<>();
|
|
|
|
|
List<DeviceIdentifier> validDeviceIDList = new ArrayList<>();
|
|
|
|
|
if (!ApplicationType.WEB_CLIP.toString().equals(applicationDTO.getType())) {
|
|
|
|
|
DeviceType deviceType = APIUtil.getDeviceTypeData(applicationDTO.getDeviceTypeId());
|
|
|
|
|
for (DeviceIdentifier deviceIdentifier : deviceIdentifiers) {
|
|
|
|
|
if (StringUtils.isEmpty(deviceIdentifier.getId()) || StringUtils.isEmpty(deviceIdentifier.getType())) {
|
|
|
|
|
log.warn("Found a device identifier which has either empty identity of the device or empty device "
|
|
|
|
|
+ "type. Hence ignoring the device identifier. ");
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!deviceType.getName().equals(deviceIdentifier.getType())) {
|
|
|
|
|
String msg =
|
|
|
|
|
"Found a device identifier which is not matched with the application device Type. Application "
|
|
|
|
|
+ "device type is " + deviceType.getName() + " and the identifier of which has a "
|
|
|
|
|
+ "different device type is " + deviceIdentifier.getId();
|
|
|
|
|
log.warn(msg);
|
|
|
|
|
errorDeviceIdList.add(deviceIdentifier);
|
|
|
|
|
} else {
|
|
|
|
|
validDeviceIDList.add(deviceIdentifier);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
for (DeviceIdentifier deviceIdentifier : deviceIdentifiers) {
|
|
|
|
|
if (StringUtils.isEmpty(deviceIdentifier.getId()) || StringUtils.isEmpty(deviceIdentifier.getType())) {
|
|
|
|
|
log.warn("Found a device identifier which has either empty identity of the device or empty device "
|
|
|
|
|
+ "type. Hence ignoring the device identifier. ");
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
validDeviceIDList.add(deviceIdentifier);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (validDeviceIDList.isEmpty()) {
|
|
|
|
|
String msg = "Couldn't found at least one valid device identifier to install the application.";
|
|
|
|
|
log.error(msg);
|
|
|
|
|
throw new BadRequestException(msg);
|
|
|
|
|
}
|
|
|
|
|
DeviceIDHolder deviceIDHolder = new DeviceIDHolder();
|
|
|
|
|
deviceIDHolder.setValidDeviceIDList(validDeviceIDList);
|
|
|
|
|
deviceIDHolder.setErrorDeviceIdList(errorDeviceIdList);
|
|
|
|
|
return deviceIDHolder;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//todo pass SubscribingDeviceIdHolder and action
|
|
|
|
|
private void addSubscriptions(int applicationReleaseId, Activity activity,
|
|
|
|
|
Map<DeviceIdentifier, Integer> compatibleDevices, List<Integer> subDeviceIds, List<String> subscribers,
|
|
|
|
|
String subType) throws ApplicationManagementException {
|
|
|
|
|
SubscribingDeviceIdHolder subscribingDeviceIdHolder, List<String> subscribers, String subType, String action)
|
|
|
|
|
throws ApplicationManagementException {
|
|
|
|
|
int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true);
|
|
|
|
|
String subscriber = PrivilegedCarbonContext.getThreadLocalCarbonContext().getUsername();
|
|
|
|
|
try {
|
|
|
|
|
@ -346,6 +336,7 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
|
|
|
|
|
List<Integer> deviceSubscriptingIds;
|
|
|
|
|
|
|
|
|
|
if (SubsciptionType.USER.toString().equals(subType)) {
|
|
|
|
|
//todo check action
|
|
|
|
|
List<String> subscribedUsers = subscriptionDAO.getSubscribedUsernames(subscribers, tenantId);
|
|
|
|
|
if (!subscribedUsers.isEmpty()) {
|
|
|
|
|
subscriptionDAO
|
|
|
|
|
@ -361,16 +352,22 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
|
|
|
|
|
List<ActivityStatus> activityStatuses = activity.getActivityStatus();
|
|
|
|
|
for (ActivityStatus status : activityStatuses) {
|
|
|
|
|
if (status.getStatus().equals(ActivityStatus.Status.PENDING)) {
|
|
|
|
|
deviceIds.add(compatibleDevices.get(status.getDeviceIdentifier()));
|
|
|
|
|
//todo
|
|
|
|
|
// deviceIds.add(compatibleDevices.get(status.getDeviceIdentifier()));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int operationId = Integer.parseInt(activity.getActivityId().split("ACTIVITY_")[1]);
|
|
|
|
|
if (!subDeviceIds.isEmpty()) {
|
|
|
|
|
deviceResubscribingIds = subscriptionDAO.updateDeviceSubscription(subscriber, subDeviceIds, subType,
|
|
|
|
|
Operation.Status.PENDING.toString(), applicationReleaseId, tenantId);
|
|
|
|
|
deviceIds.removeAll(subDeviceIds);
|
|
|
|
|
}
|
|
|
|
|
//todo if INSTALL get Ids of subscribable devices and update those ids and insert other ids
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//todo
|
|
|
|
|
|
|
|
|
|
// if (!subDeviceIds.isEmpty()) {
|
|
|
|
|
// deviceResubscribingIds = subscriptionDAO.updateDeviceSubscription(subscriber, subDeviceIds, subType,
|
|
|
|
|
// Operation.Status.PENDING.toString(), applicationReleaseId, tenantId);
|
|
|
|
|
// deviceIds.removeAll(subDeviceIds);
|
|
|
|
|
// }
|
|
|
|
|
deviceSubscriptingIds = subscriptionDAO
|
|
|
|
|
.subscribeDeviceToApplication(subscriber, deviceIds, subType, Operation.Status.PENDING.toString(),
|
|
|
|
|
applicationReleaseId, tenantId);
|
|
|
|
|
@ -419,164 +416,12 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//todo remove below methods
|
|
|
|
|
|
|
|
|
|
@Override public ApplicationInstallResponse installApplicationForUsers(String applicationUUID,
|
|
|
|
|
List<String> userList) throws ApplicationManagementException {
|
|
|
|
|
if (log.isDebugEnabled()) {
|
|
|
|
|
log.debug("Install application release which has UUID " + applicationUUID + " to " + userList.size()
|
|
|
|
|
+ " users.");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//todo check valid user list - throw BadRequest exception
|
|
|
|
|
ApplicationDTO applicationDTO = getApplicationDTO(applicationUUID);
|
|
|
|
|
DeviceType appDeviceType = APIUtil.getDeviceTypeData(applicationDTO.getDeviceTypeId());
|
|
|
|
|
Map<DeviceIdentifier, Integer> compatibleDevices = new HashMap<>();
|
|
|
|
|
List<DeviceIdentifier> installedDeviceIdentifiers = new ArrayList<>();
|
|
|
|
|
Map<Integer, DeviceSubscriptionDTO> deviceSubscriptions = new HashMap<>();
|
|
|
|
|
|
|
|
|
|
for (String user : userList) {
|
|
|
|
|
try {
|
|
|
|
|
List<Device> userDevices = HelperUtil.getDeviceManagementProviderService().getDevicesOfUser(user);
|
|
|
|
|
List<Device> filteredDevices = new ArrayList<>();
|
|
|
|
|
|
|
|
|
|
//todo improve for web clips
|
|
|
|
|
for (Device device : userDevices) {
|
|
|
|
|
if (appDeviceType.getName().equals(device.getType())) {
|
|
|
|
|
filteredDevices.add(device);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
SubscribingDeviceIdHolder subscribingDeviceIdHolder = getSubscribingDeviceIdHolder(filteredDevices);
|
|
|
|
|
compatibleDevices.putAll(subscribingDeviceIdHolder.getCompatibleDevices());
|
|
|
|
|
deviceSubscriptions.putAll(subscribingDeviceIdHolder.getDeviceSubscriptions());
|
|
|
|
|
installedDeviceIdentifiers.addAll(subscribingDeviceIdHolder.getInstalledDevices());
|
|
|
|
|
} catch (DeviceManagementException e) {
|
|
|
|
|
String msg = "Error occurred when extracting the device list of user[" + user + "].";
|
|
|
|
|
log.error(msg);
|
|
|
|
|
throw new ApplicationManagementException(msg, e);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (compatibleDevices.keySet().isEmpty()) {
|
|
|
|
|
ApplicationInstallResponse applicationInstallResponse = new ApplicationInstallResponse();
|
|
|
|
|
applicationInstallResponse.setAlreadyInstalledDevices(installedDeviceIdentifiers);
|
|
|
|
|
return applicationInstallResponse;
|
|
|
|
|
}
|
|
|
|
|
Activity activity = addAppInstallOperationToDevices(applicationDTO, new ArrayList<>(compatibleDevices.keySet()),
|
|
|
|
|
appDeviceType.getName());
|
|
|
|
|
|
|
|
|
|
ApplicationInstallResponse applicationInstallResponse = new ApplicationInstallResponse();
|
|
|
|
|
applicationInstallResponse.setActivity(activity);
|
|
|
|
|
applicationInstallResponse.setAlreadyInstalledDevices(installedDeviceIdentifiers);
|
|
|
|
|
|
|
|
|
|
addSubscriptions(applicationDTO.getApplicationReleaseDTOs().get(0).getId(), activity, compatibleDevices,
|
|
|
|
|
new ArrayList<>(deviceSubscriptions.keySet()), userList, SubsciptionType.USER.toString());
|
|
|
|
|
return applicationInstallResponse;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//todo not implemented below code properly
|
|
|
|
|
|
|
|
|
|
@Override public ApplicationInstallResponseTmp installApplicationForRoles(String applicationUUID,
|
|
|
|
|
List<String> roleList) throws ApplicationManagementException {
|
|
|
|
|
if (log.isDebugEnabled()) {
|
|
|
|
|
log.debug("Install application: " + applicationUUID + " to " + roleList.size() + " roles.");
|
|
|
|
|
}
|
|
|
|
|
ApplicationManager applicationManager = DataHolder.getInstance().getApplicationManager();
|
|
|
|
|
ApplicationDTO application = applicationManager.getApplicationByRelease(applicationUUID);
|
|
|
|
|
List<DeviceIdentifier> deviceList = new ArrayList<>();
|
|
|
|
|
for (String role : roleList) {
|
|
|
|
|
try {
|
|
|
|
|
List<Device> devicesOfRole = HelperUtil.getDeviceManagementProviderService().getAllDevicesOfRole(role);
|
|
|
|
|
devicesOfRole.stream()
|
|
|
|
|
.map(device -> new DeviceIdentifier(device.getDeviceIdentifier(), device.getType()))
|
|
|
|
|
.forEach(deviceList::add);
|
|
|
|
|
if (log.isDebugEnabled()) {
|
|
|
|
|
log.debug(devicesOfRole.size() + " found for role: " + role);
|
|
|
|
|
}
|
|
|
|
|
} catch (DeviceManagementException e) {
|
|
|
|
|
throw new ApplicationManagementException(
|
|
|
|
|
"Error when extracting the device list from role[" + role + "].", e);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ApplicationInstallResponseTmp response = installToDevicesTmp(application, deviceList);
|
|
|
|
|
|
|
|
|
|
int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true);
|
|
|
|
|
String subscriber = PrivilegedCarbonContext.getThreadLocalCarbonContext().getUsername();
|
|
|
|
|
int applicationReleaseId = application.getApplicationReleaseDTOs().get(0).getId();
|
|
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
ConnectionManagerUtil.openDBConnection();
|
|
|
|
|
subscriptionDAO.subscribeRoleToApplication(tenantId, subscriber, roleList, application.getId(),
|
|
|
|
|
applicationReleaseId);
|
|
|
|
|
} catch (ApplicationManagementDAOException e) {
|
|
|
|
|
//todo
|
|
|
|
|
throw new ApplicationManagementException("");
|
|
|
|
|
} finally {
|
|
|
|
|
ConnectionManagerUtil.closeDBConnection();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return response;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@Override public ApplicationInstallResponseTmp installApplicationForGroups(String applicationUUID,
|
|
|
|
|
List<String> deviceGroupList) throws ApplicationManagementException {
|
|
|
|
|
if (log.isDebugEnabled()) {
|
|
|
|
|
log.debug("Install application: " + applicationUUID + " to " + deviceGroupList.size() + " groups.");
|
|
|
|
|
}
|
|
|
|
|
ApplicationManager applicationManager = DataHolder.getInstance().getApplicationManager();
|
|
|
|
|
ApplicationDTO application = applicationManager.getApplicationByRelease(applicationUUID);
|
|
|
|
|
GroupManagementProviderService groupManagementProviderService = HelperUtil.getGroupManagementProviderService();
|
|
|
|
|
List<DeviceGroup> groupList = new ArrayList<>();
|
|
|
|
|
List<DeviceIdentifier> deviceList = new ArrayList<>();
|
|
|
|
|
for (String groupName : deviceGroupList) {
|
|
|
|
|
try {
|
|
|
|
|
DeviceGroup deviceGroup = groupManagementProviderService.getGroup(groupName);
|
|
|
|
|
groupList.add(deviceGroup);
|
|
|
|
|
int deviceCount = groupManagementProviderService.getDeviceCount(deviceGroup.getGroupId());
|
|
|
|
|
List<Device> devicesOfGroups = groupManagementProviderService
|
|
|
|
|
.getDevices(deviceGroup.getGroupId(), 0, deviceCount);
|
|
|
|
|
devicesOfGroups.stream()
|
|
|
|
|
.map(device -> new DeviceIdentifier(device.getDeviceIdentifier(), device.getType()))
|
|
|
|
|
.forEach(deviceList::add);
|
|
|
|
|
} catch (GroupManagementException e) {
|
|
|
|
|
throw new ApplicationManagementException(
|
|
|
|
|
"Error when extracting the device list from group[" + groupName + "].", e);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ApplicationInstallResponseTmp response = installToDevicesTmp(application, deviceList);
|
|
|
|
|
|
|
|
|
|
int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true);
|
|
|
|
|
String subscriber = PrivilegedCarbonContext.getThreadLocalCarbonContext().getUsername();
|
|
|
|
|
int applicationReleaseId = application.getApplicationReleaseDTOs().get(0).getId();
|
|
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
ConnectionManagerUtil.openDBConnection();
|
|
|
|
|
subscriptionDAO.subscribeGroupToApplication(tenantId, subscriber, groupList, application.getId(),
|
|
|
|
|
applicationReleaseId);
|
|
|
|
|
} catch (ApplicationManagementDAOException e) {
|
|
|
|
|
//todo
|
|
|
|
|
throw new ApplicationManagementException("");
|
|
|
|
|
} finally {
|
|
|
|
|
ConnectionManagerUtil.closeDBConnection();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return response;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@Override public List<DeviceIdentifier> uninstallApplication(String applicationUUID,
|
|
|
|
|
List<DeviceIdentifier> deviceList) throws ApplicationManagementException {
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private Activity addAppInstallOperationToDevices(ApplicationDTO application,
|
|
|
|
|
List<DeviceIdentifier> deviceIdentifierList, String deviceType) throws ApplicationManagementException {
|
|
|
|
|
DeviceManagementProviderService deviceManagementProviderService = HelperUtil
|
|
|
|
|
.getDeviceManagementProviderService();
|
|
|
|
|
try {
|
|
|
|
|
Operation operation = generateOperationPayloadByDeviceType(deviceType, application);
|
|
|
|
|
Operation operation = generateOperationPayloadByDeviceType(deviceType, application, null);
|
|
|
|
|
//todo refactor add operation code to get successful operations
|
|
|
|
|
return deviceManagementProviderService.addOperation(deviceType, operation, deviceIdentifierList);
|
|
|
|
|
} catch (OperationManagementException e) {
|
|
|
|
|
@ -588,105 +433,43 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private ApplicationInstallResponseTmp installToDevicesTmp(ApplicationDTO application,
|
|
|
|
|
List<DeviceIdentifier> deviceIdentifierList) throws ApplicationManagementException {
|
|
|
|
|
DeviceManagementProviderService deviceManagementProviderService = HelperUtil
|
|
|
|
|
.getDeviceManagementProviderService();
|
|
|
|
|
|
|
|
|
|
ApplicationInstallResponseTmp response = validateDevices(deviceIdentifierList);
|
|
|
|
|
/*
|
|
|
|
|
Group the valid device list by device type. Following lambda expression produces a map containing device type
|
|
|
|
|
as the key and the list of device identifiers as the corresponding value.
|
|
|
|
|
*/
|
|
|
|
|
Map<String, List<DeviceIdentifier>> deviceTypeIdentifierMap = response.getSuccessfulDevices().stream()
|
|
|
|
|
.collect(Collectors.groupingBy(DeviceIdentifier::getType));
|
|
|
|
|
|
|
|
|
|
for (Map.Entry<String, List<DeviceIdentifier>> entry : deviceTypeIdentifierMap.entrySet()) {
|
|
|
|
|
Operation operation = generateOperationPayloadByDeviceType(entry.getKey(), application);
|
|
|
|
|
try {
|
|
|
|
|
Activity activity = deviceManagementProviderService
|
|
|
|
|
.addOperation(entry.getKey(), operation, entry.getValue());
|
|
|
|
|
response.setActivity(activity);
|
|
|
|
|
} catch (OperationManagementException e) {
|
|
|
|
|
response.setSuccessfulDevices(null);
|
|
|
|
|
response.setFailedDevices(deviceIdentifierList);
|
|
|
|
|
throw new ApplicationManagementException(
|
|
|
|
|
"Error occurred while adding the application install " + "operation to devices", e);
|
|
|
|
|
} catch (InvalidDeviceException e) {
|
|
|
|
|
//This exception should not occur because the validation has already been done.
|
|
|
|
|
throw new ApplicationManagementException("The list of device identifiers are invalid");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true);
|
|
|
|
|
String subscriber = PrivilegedCarbonContext.getThreadLocalCarbonContext().getUsername();
|
|
|
|
|
int applicationReleaseId = application.getApplicationReleaseDTOs().get(0).getId();
|
|
|
|
|
private Operation generateOperationPayloadByDeviceType(String deviceType, ApplicationDTO application, String action)
|
|
|
|
|
throws ApplicationManagementException {
|
|
|
|
|
try {
|
|
|
|
|
ConnectionManagerUtil.openDBConnection();
|
|
|
|
|
List<Device> deviceList = new ArrayList<>();
|
|
|
|
|
for (DeviceIdentifier deviceIdentifier : response.getSuccessfulDevices()) {
|
|
|
|
|
try {
|
|
|
|
|
deviceList.add(deviceManagementProviderService.getDevice(deviceIdentifier));
|
|
|
|
|
} catch (DeviceManagementException e) {
|
|
|
|
|
log.error("Unable to fetch device for device identifier: " + deviceIdentifier.toString());
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
subscriptionDAO.subscribeDeviceToApplicationTmp(tenantId, subscriber, deviceList, application.getId(),
|
|
|
|
|
applicationReleaseId, String.valueOf(AppOperation.InstallState.UNINSTALLED));
|
|
|
|
|
} catch (ApplicationManagementDAOException e) {
|
|
|
|
|
//todo
|
|
|
|
|
throw new ApplicationManagementException("");
|
|
|
|
|
} finally {
|
|
|
|
|
ConnectionManagerUtil.closeDBConnection();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return response;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private Operation generateOperationPayloadByDeviceType(String deviceType, ApplicationDTO application) {
|
|
|
|
|
ProfileOperation operation = new ProfileOperation();
|
|
|
|
|
operation.setCode(INSTALL_APPLICATION);
|
|
|
|
|
operation.setType(Operation.Type.PROFILE);
|
|
|
|
|
|
|
|
|
|
//todo: generate operation payload correctly for all types of devices.
|
|
|
|
|
operation.setPayLoad(
|
|
|
|
|
"{'type':'enterprise', 'url':'" + application.getApplicationReleaseDTOs().get(0).getInstallerName()
|
|
|
|
|
+ "', 'app':'" + application.getApplicationReleaseDTOs().get(0).getUuid() + "'}");
|
|
|
|
|
return operation;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Validates the preconditions which is required to satisfy from the device which is required to install the
|
|
|
|
|
* application.
|
|
|
|
|
* <p>
|
|
|
|
|
* This method check two preconditions whether the application type is compatible to install in the device and
|
|
|
|
|
* whether the device is enrolled in the system.
|
|
|
|
|
*
|
|
|
|
|
* @param deviceIdentifierList List of {@link DeviceIdentifier} which the validation happens
|
|
|
|
|
* @return {@link ApplicationInstallResponseTmp} which contains compatible and incompatible device identifiers
|
|
|
|
|
*/
|
|
|
|
|
private ApplicationInstallResponseTmp validateDevices(List<DeviceIdentifier> deviceIdentifierList) {
|
|
|
|
|
ApplicationInstallResponseTmp applicationInstallResponseTmp = new ApplicationInstallResponseTmp();
|
|
|
|
|
List<DeviceIdentifier> failedDevices = new ArrayList<>();
|
|
|
|
|
List<DeviceIdentifier> compatibleDevices = new ArrayList<>();
|
|
|
|
|
|
|
|
|
|
for (DeviceIdentifier deviceIdentifier : deviceIdentifierList) {
|
|
|
|
|
try {
|
|
|
|
|
if (!DeviceManagerUtil.isValidDeviceIdentifier(deviceIdentifier)) {
|
|
|
|
|
log.error("Device with ID: [" + deviceIdentifier.getId() + "] is not valid to install the "
|
|
|
|
|
+ "application.");
|
|
|
|
|
applicationInstallResponseTmp.getFailedDevices().add(deviceIdentifier);
|
|
|
|
|
//todo rethink and modify the {@link MobileApp} usage
|
|
|
|
|
MobileApp mobileApp = new MobileApp();
|
|
|
|
|
if (DeviceTypes.ANDROID.toString().equalsIgnoreCase(deviceType)) {
|
|
|
|
|
if (SubAction.INSTALL.toString().equalsIgnoreCase(action)) {
|
|
|
|
|
return MDMAndroidOperationUtil.createInstallAppOperation(mobileApp);
|
|
|
|
|
} else if (SubAction.UNINSTALL.toString().equalsIgnoreCase(action)) {
|
|
|
|
|
return MDMAndroidOperationUtil.createAppUninstallOperation(mobileApp);
|
|
|
|
|
} else {
|
|
|
|
|
String msg = "Invalid Action is found. Action: " + action;
|
|
|
|
|
log.error(msg);
|
|
|
|
|
throw new ApplicationManagementException(msg);
|
|
|
|
|
}
|
|
|
|
|
} else if (DeviceTypes.IOS.toString().equalsIgnoreCase(deviceType)) {
|
|
|
|
|
if (SubAction.INSTALL.toString().equalsIgnoreCase(action)) {
|
|
|
|
|
return MDMIOSOperationUtil.createInstallAppOperation(mobileApp);
|
|
|
|
|
} else if (SubAction.UNINSTALL.toString().equalsIgnoreCase(action)) {
|
|
|
|
|
return MDMIOSOperationUtil.createAppUninstallOperation(mobileApp);
|
|
|
|
|
} else {
|
|
|
|
|
String msg = "Invalid Action is found. Action: " + action;
|
|
|
|
|
log.error(msg);
|
|
|
|
|
throw new ApplicationManagementException(msg);
|
|
|
|
|
}
|
|
|
|
|
} catch (DeviceManagementException e) {
|
|
|
|
|
log.error("Error occurred while validating the device: [" + deviceIdentifier.getId() + "]", e);
|
|
|
|
|
failedDevices.add(deviceIdentifier);
|
|
|
|
|
} else {
|
|
|
|
|
String msg = "Invalid device type is found. Device Type: " + deviceType;
|
|
|
|
|
log.error(msg);
|
|
|
|
|
throw new ApplicationManagementException(msg);
|
|
|
|
|
}
|
|
|
|
|
compatibleDevices.add(deviceIdentifier);
|
|
|
|
|
}
|
|
|
|
|
applicationInstallResponseTmp.setFailedDevices(failedDevices);
|
|
|
|
|
applicationInstallResponseTmp.setSuccessfulDevices(compatibleDevices);
|
|
|
|
|
|
|
|
|
|
return applicationInstallResponseTmp;
|
|
|
|
|
} catch (UnknownApplicationTypeException e) {
|
|
|
|
|
String msg = "Unknown Application type is found.";
|
|
|
|
|
log.error(msg);
|
|
|
|
|
throw new ApplicationManagementException(msg);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
Dharmakeerthi Lasantha
5 years ago