Improve APPM subscribing method

components/application-mgt/org.wso2.carbon.device.application.mgt.common/src/main/java/org/wso2/carbon/device/application/mgt/common/ApplicationInstallResponse.java

@@ -32,6 +32,14 @@ public class ApplicationInstallResponse {
     )
     private List<DeviceIdentifier> alreadyInstalledDevices;
 
+    @ApiModelProperty(
+            name = "errorDevices",
+            value = "List of devices that either device identity is not exist or device type doesn't compatible with the supported device type of the .",
+            dataType = "List[org.wso2.carbon.device.mgt.common.DeviceIdentifier]"
+    )
+    private List<DeviceIdentifier> errorDevices;
+
+
     @ApiModelProperty(
             name = "activity",
             value = "Activity corresponding to the operation"
@@ -53,4 +61,8 @@ public class ApplicationInstallResponse {
     public void setAlreadyInstalledDevices(List<DeviceIdentifier> alreadyInstalledDevices) {
         this.alreadyInstalledDevices = alreadyInstalledDevices;
     }
+
+    public List<DeviceIdentifier> getErrorDevices() { return errorDevices; }
+
+    public void setErrorDevices(List<DeviceIdentifier> errorDevices) { this.errorDevices = errorDevices; }
 }

components/application-mgt/org.wso2.carbon.device.application.mgt.common/src/main/java/org/wso2/carbon/device/application/mgt/common/SubscribingDeviceIdHolder.java

@@ -0,0 +1,56 @@
+/* Copyright (c) 2019, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
+ *
+ * Entgra (Pvt) Ltd. 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.application.mgt.common;
+
+import org.wso2.carbon.device.application.mgt.common.dto.DeviceSubscriptionDTO;
+import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class SubscribingDeviceIdHolder {
+    private List<DeviceIdentifier> installedDevices = new ArrayList<>();
+    private Map<DeviceIdentifier, Integer> compatibleDevices = new HashMap<>();
+    private Map<Integer, DeviceSubscriptionDTO> deviceSubscriptions = new HashMap<>();
+
+    public List<DeviceIdentifier> getInstalledDevices() {
+        return installedDevices;
+    }
+
+    public void setInstalledDevices(List<DeviceIdentifier> installedDevices) {
+        this.installedDevices = installedDevices;
+    }
+
+    public Map<DeviceIdentifier, Integer> getCompatibleDevices() {
+        return compatibleDevices;
+    }
+
+    public void setCompatibleDevices(Map<DeviceIdentifier, Integer> compatibleDevices) {
+        this.compatibleDevices = compatibleDevices;
+    }
+
+    public Map<Integer, DeviceSubscriptionDTO> getDeviceSubscriptions() {
+        return deviceSubscriptions;
+    }
+
+    public void setDeviceSubscriptions(Map<Integer, DeviceSubscriptionDTO> deviceSubscriptions) {
+        this.deviceSubscriptions = deviceSubscriptions;
+    }
+}

components/application-mgt/org.wso2.carbon.device.application.mgt.common/src/main/java/org/wso2/carbon/device/application/mgt/common/services/ReviewManager.java

@@ -84,5 +84,5 @@ public interface ReviewManager {
      * @return {@link Review}updated review
      * @throws ReviewManagementException Exceptions of the review management
      */
-    Rating getRating(String appReleaseUuuid) throws ReviewManagementException;
+    Rating getRating(String appReleaseUuuid) throws ReviewManagementException, ApplicationManagementException;
 }

components/application-mgt/org.wso2.carbon.device.application.mgt.common/src/main/java/org/wso2/carbon/device/application/mgt/common/services/SubscriptionManager.java

@@ -39,6 +39,9 @@ public interface SubscriptionManager {
     ApplicationInstallResponse installApplicationForDevices(String applicationUUID, List<DeviceIdentifier> deviceList)
             throws ApplicationManagementException;
 
+    ApplicationInstallResponse addBulkApInstallation(String applicationUUID, List<String> subscriberList,
+            String subType) throws ApplicationManagementException;
+
     /**
      * To install an application to given list of users.
      * @param applicationUUID ID of the application to install

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/impl/ApplicationManagerImpl.java

@@ -1,21 +1,20 @@
-/*
+/* Copyright (c) 2019, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
- *   Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
  *
- *   WSO2 Inc. licenses this file to you under the Apache License,
+ * Entgra (Pvt) Ltd. licenses this file to you under the Apache License,
- *   Version 2.0 (the "License"); you may not use this file except
+ * Version 2.0 (the "License"); you may not use this file except
- *   in compliance with the License.
+ * in compliance with the License.
- *   You may obtain a copy of the License at
+ * You may obtain a copy of the License at
  *
- *   http://www.apache.org/licenses/LICENSE-2.0
+ *    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.
  *
+ * 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.application.mgt.core.impl;
 
 import org.apache.commons.io.IOUtils;

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/impl/ApplicationStorageManagerImpl.java

@@ -1,20 +1,18 @@
-/*
+/* Copyright (c) 2019, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
- *   Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
  *
- *   WSO2 Inc. licenses this file to you under the Apache License,
+ * Entgra (Pvt) Ltd. licenses this file to you under the Apache License,
- *   Version 2.0 (the "License"); you may not use this file except
+ * Version 2.0 (the "License"); you may not use this file except
- *   in compliance with the License.
+ * in compliance with the License.
- *   You may obtain a copy of the License at
+ * You may obtain a copy of the License at
  *
- *   http://www.apache.org/licenses/LICENSE-2.0
+ *    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.
  *
+ * 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.application.mgt.core.impl;

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/impl/AppmDataHandlerImpl.java

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
+/* Copyright (c) 2019, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
  *
  * Entgra (Pvt) Ltd. licenses this file to you under the Apache License,
  * Version 2.0 (the "License"); you may not use this file except

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/impl/ReviewManagerImpl.java

@@ -1,20 +1,20 @@
-/*
+/* Copyright (c) 2019, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
- *  Copyright (c) 2018, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
- *  WSO2 Inc. licenses this file to you under the Apache License,
+ * Entgra (Pvt) Ltd. licenses this file to you under the Apache License,
- *  Version 2.0 (the "License"); you may not use this file except
+ * Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License.
+ * in compliance with the License.
- *  You may obtain a copy of the License at
+ * 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
+ * KIND, either express or implied. See the License for the
  * specific language governing permissions and limitations
  * under the License.
- *
  */
+
 package org.wso2.carbon.device.application.mgt.core.impl;
 
 import org.apache.commons.logging.Log;
@@ -49,6 +49,7 @@ import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 import java.util.TreeMap;
+import java.util.stream.IntStream;
 
 /**
  * This class is the default implementation for the Managing the reviews.
@@ -467,26 +468,29 @@ public class ReviewManagerImpl implements ReviewManager {
         }
     }
 
-    @Override public Rating getRating(String appReleaseUuuid) throws ReviewManagementException {
+    @Override public Rating getRating(String appReleaseUuuid) throws ReviewManagementException, ApplicationManagementException {
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true);
         try {
             ConnectionManagerUtil.openDBConnection();
             Rating rating = this.applicationReleaseDAO.getRating(appReleaseUuuid, tenantId);
             if (rating == null) {
-                throw new ReviewManagementException(
+                throw new NotFoundException(
                         "Couldn't find rating for application release UUID: " + appReleaseUuuid
                                 + ". Please check the existence of the application release");
             }
 
             List<Integer> ratingValues = this.reviewDAO.getAllRatingValues(appReleaseUuuid, tenantId);
             TreeMap<Integer, Integer> ratingVariety = new TreeMap<>();
-            for (Integer ratingVal : ratingValues) {
+            ratingValues.forEach(ratingVal -> {
                 if (ratingVariety.containsKey(ratingVal)) {
                     ratingVariety.replace(ratingVal, ratingVariety.get(ratingVal) + 1);
                 } else {
                     ratingVariety.put(ratingVal, 1);
                 }
-            }
+            });
+            IntStream.rangeClosed(1, Constants.MAX_RATING).filter(i -> !ratingVariety.containsKey(i))
+                    .forEach(i -> ratingVariety.put(i, 0));
+
             rating.setRatingVariety(ratingVariety);
             return rating;
         } catch (ApplicationManagementDAOException e) {

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/impl/SubscriptionManagerImpl.java

@@ -1,22 +1,23 @@
-/*
+/* Copyright (c) 2019, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.
-*  Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
-*  WSO2 Inc. licenses this file to you under the Apache License,
+ * Entgra (Pvt) Ltd. licenses this file to you under the Apache License,
-*  Version 2.0 (the "License"); you may not use this file except
+ * Version 2.0 (the "License"); you may not use this file except
-*  in compliance with the License.
+ * in compliance with the License.
-*  You may obtain a copy of the License at
+ * You may obtain a copy of the License at
-*
+ *
-*    http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
-*
+ *
-* Unless required by applicable law or agreed to in writing,
+ * Unless required by applicable law or agreed to in writing,
-* software distributed under the License is distributed on an
+ * software distributed under the License is distributed on an
-* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-* KIND, either express or implied.  See the License for the
+ * KIND, either express or implied. See the License for the
-* specific language governing permissions and limitations
+ * specific language governing permissions and limitations
-* under the License.
+ * under the License.
-*
+ */
-*/
+
 package org.wso2.carbon.device.application.mgt.core.impl;
 
+import org.apache.commons.lang.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.wso2.carbon.context.PrivilegedCarbonContext;
@@ -24,6 +25,7 @@ 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.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;
@@ -55,9 +57,9 @@ 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.DeviceManagementConstants;
 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;
@@ -85,59 +87,168 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
         this.applicationDAO = ApplicationManagementDAOFactory.getApplicationDAO();
     }
 
-    @Override
+    @Override public ApplicationInstallResponse installApplicationForDevices(String applicationUUID,
-    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.");
         }
+        DeviceManagementProviderService deviceManagementProviderService = HelperUtil
+                .getDeviceManagementProviderService();
         ApplicationDTO applicationDTO = getApplicationDTO(applicationUUID);
-        List<Integer> operationTriggeredDeviceIds = new ArrayList<>();
+        DeviceIDHolder filteredDeviceHolder = filterDeviceIdentifiers(applicationDTO, deviceIdentifiers);
-        List <Device> filteredDevices = validateAppInstallingForDevicesRequest(applicationDTO, deviceIdentifiers);
+        List<DeviceIdentifier> errorDeviceIdentifiers = filteredDeviceHolder.getErrorDeviceIdList();
-        List<Integer> filteredDeviceIds = new ArrayList<>();
+        List<Device> filteredDeviceObjs = new ArrayList<>();
-        List<DeviceIdentifier> installedDeviceIdentifiers = new ArrayList<>();
-        Map<DeviceIdentifier , Integer> compatibleDevices = new HashMap<>();
-        Map<Integer, DeviceSubscriptionDTO> deviceSubscriptions;
 
-        for (Device device : filteredDevices){
+        //getting device objects by using device identifiers
-            filteredDeviceIds.add(device.getId());
+        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;
+        }
+    }
 
-        deviceSubscriptions = getDeviceSubscriptions(filteredDeviceIds);
+    @Override
-        for (Device device : filteredDevices) {
+    public ApplicationInstallResponse addBulkApInstallation(String applicationUUID, List<String> subscriberList,
-            DeviceIdentifier deviceIdentifier = new DeviceIdentifier(device.getDeviceIdentifier(),
+            String subType) throws ApplicationManagementException {
-                    device.getType());
+        if (log.isDebugEnabled()) {
-            DeviceSubscriptionDTO deviceSubscriptionDTO = deviceSubscriptions.get(device.getId());
+            log.debug("Install application release which has UUID " + applicationUUID + " to " + subscriberList.size()
-            if (deviceSubscriptionDTO != null && !deviceSubscriptionDTO.isUnsubscribed()
+                    + " users.");
-                    && Operation.Status.COMPLETED.toString().equals(deviceSubscriptionDTO.getStatus())) {
+        }
-                installedDeviceIdentifiers.add(deviceIdentifier);
+
+        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.";
+                log.error(msg);
+                throw new BadRequestException(msg);
+            }
+            if (SubsciptionType.USER.toString().equals(subType) && !SubsciptionType.ROLE.toString().equals(subType)
+                    && SubsciptionType.GROUP.toString().equals(subType)) {
+                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));
+                }
+            }
+
+            if (!ApplicationType.WEB_CLIP.toString().equals(applicationDTO.getType())) {
+                DeviceType deviceType = APIUtil.getDeviceTypeData(applicationDTO.getDeviceTypeId());
+                String deviceTypeName = deviceType.getName();
+                for (Device device : subscriberDevices) {
+                    if (deviceTypeName.equals(device.getType())) {
+                        filteredDevices.add(device);
+                    }
+                }
+                return installToDevices(deviceTypeName, filteredDevices, applicationDTO, subType, subscriberList);
             } else {
-                compatibleDevices.put(deviceIdentifier, device.getId());
+                //todo improve this
+                return installToDevices(null, subscriberDevices, applicationDTO, subType, subscriberList);
             }
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while getting devices of given users or given roles.";
+            log.error(msg);
+            throw new ApplicationManagementException(msg, e);
+        } catch (GroupManagementException e) {
+            String msg = "Error occurred while getting devices of given groups";
+            log.error(msg);
+            throw new ApplicationManagementException(msg, e);
         }
-        Activity activity = installToDevices(applicationDTO, deviceIdentifiers, deviceIdentifiers.get(0).getType());
+    }
 
-        List<ActivityStatus> activityStatuses = activity.getActivityStatus();
+    private ApplicationInstallResponse installToDevices(String deviceType, List<Device> devices,
-        for (ActivityStatus status : activityStatuses) {
+            ApplicationDTO applicationDTO, String subType, List<String> subscribers)
-            if (status.getStatus().equals(ActivityStatus.Status.PENDING)){
+            throws ApplicationManagementException {
-                operationTriggeredDeviceIds.add(compatibleDevices.get(status.getDeviceIdentifier()));
+
-            }
+        SubscribingDeviceIdHolder subscribingDeviceIdHolder = getSubscribingDeviceIdHolder(devices);
+        if (subscribingDeviceIdHolder.getCompatibleDevices().isEmpty()) {
+            ApplicationInstallResponse applicationInstallResponse = new ApplicationInstallResponse();
+            applicationInstallResponse.setAlreadyInstalledDevices(subscribingDeviceIdHolder.getInstalledDevices());
+            return applicationInstallResponse;
         }
+        Activity activity = addAppInstallOperationToDevices(applicationDTO,
+                new ArrayList<>(subscribingDeviceIdHolder.getCompatibleDevices().keySet()), deviceType);
+
         ApplicationInstallResponse applicationInstallResponse = new ApplicationInstallResponse();
         applicationInstallResponse.setActivity(activity);
-        applicationInstallResponse.setAlreadyInstalledDevices(installedDeviceIdentifiers);
+        applicationInstallResponse.setAlreadyInstalledDevices(subscribingDeviceIdHolder.getInstalledDevices());
 
-//        int operationId = Integer
+        addSubscriptions(applicationDTO.getApplicationReleaseDTOs().get(0).getId(), activity,
-//                .parseInt(activity.getActivityId().split(DeviceManagementConstants.OperationAttributes.ACTIVITY)[1]);
+                subscribingDeviceIdHolder.getCompatibleDevices(),
-        int operationId = Integer.parseInt(activity.getActivityId().split("ACTIVITY_")[1]);
+                new ArrayList<>(subscribingDeviceIdHolder.getDeviceSubscriptions().keySet()), subscribers, subType);
-        addDeviceSubscriptions(applicationDTO.getApplicationReleaseDTOs().get(0).getId(),
-                operationTriggeredDeviceIds, new ArrayList<>(deviceSubscriptions.keySet()), null, operationId,
-                SubsciptionType.DEVICE.toString());
         return applicationInstallResponse;
     }
 
+    private SubscribingDeviceIdHolder getSubscribingDeviceIdHolder(List<Device> devices)
+            throws ApplicationManagementException {
+        List<DeviceIdentifier> installedDevices = new ArrayList<>();
+        Map<DeviceIdentifier, Integer> compatibleDevices = new HashMap<>();
+
+        List<Integer> filteredDeviceIds = devices.stream().map(Device::getId).collect(Collectors.toList());
+        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);
+            } else {
+                compatibleDevices.put(deviceIdentifier, device.getId());
+            }
+        }
+
+        SubscribingDeviceIdHolder subscribingDeviceIdHolder = new SubscribingDeviceIdHolder();
+        subscribingDeviceIdHolder.setCompatibleDevices(compatibleDevices);
+        subscribingDeviceIdHolder.setInstalledDevices(installedDevices);
+        subscribingDeviceIdHolder.setDeviceSubscriptions(deviceSubscriptions);
+        return subscribingDeviceIdHolder;
+    }
+
     private ApplicationDTO getApplicationDTO(String uuid) throws ApplicationManagementException {
         ApplicationDTO applicationDTO;
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true);
@@ -173,117 +284,54 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
         }
     }
 
-    private List <Device> validateAppInstallingForDevicesRequest(ApplicationDTO applicationDTO,
+    private DeviceIDHolder filterDeviceIdentifiers(ApplicationDTO applicationDTO,
             List<DeviceIdentifier> deviceIdentifiers) throws ApplicationManagementException {
-        DeviceType deviceType = null;
+        List<DeviceIdentifier> errorDeviceIdList = new ArrayList<>();
-        List <Device> existingDevices = new ArrayList<>();
+        List<DeviceIdentifier> validDeviceIDList = new ArrayList<>();
-        DeviceManagementProviderService deviceManagementProviderService = HelperUtil
-                .getDeviceManagementProviderService();
         if (!ApplicationType.WEB_CLIP.toString().equals(applicationDTO.getType())) {
-            deviceType = APIUtil.getDeviceTypeData(applicationDTO.getDeviceTypeId());
+            DeviceType deviceType = APIUtil.getDeviceTypeData(applicationDTO.getDeviceTypeId());
-        }
+            for (DeviceIdentifier deviceIdentifier : deviceIdentifiers) {
-
+                if (StringUtils.isEmpty(deviceIdentifier.getId()) || StringUtils.isEmpty(deviceIdentifier.getType())) {
-        for (DeviceIdentifier deviceIdentifier : deviceIdentifiers) {
+                    log.warn("Found a device identifier which has either empty identity of the device or empty device "
-            if (!ApplicationType.WEB_CLIP.toString().equals(applicationDTO.getType()) && deviceType != null
+                            + "type. Hence ignoring the device identifier. ");
-                    && !deviceType.getName().equals(deviceIdentifier.getType())) {
+                    continue;
-                String msg =
+                }
-                        "Found a device identifier which is not matched with the application device Type. Application "
+                if (!deviceType.getName().equals(deviceIdentifier.getType())) {
-                                + "device type is " + deviceType.getName()
+                    String msg =
-                                + " and identifier which has different device" + " type is " + deviceIdentifier.getId();
+                            "Found a device identifier which is not matched with the application device Type. Application "
-                log.error(msg);
+                                    + "device type is " + deviceType.getName() + " and the identifier of which has a "
-                throw new BadRequestException(msg);
+                                    + "different device type is " + deviceIdentifier.getId();
-            }
+                    log.warn(msg);
-            try {
+                    errorDeviceIdList.add(deviceIdentifier);
-                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.error(msg);
                 } else {
-                    existingDevices.add(device);
+                    validDeviceIDList.add(deviceIdentifier);
                 }
-            } catch (DeviceManagementException e) {
-                String msg = "Error occuered when getting device data for divice identifier " + deviceIdentifier.getId()
-                        + " and device type " + deviceIdentifier.getType();
-                log.error(msg);
-                throw new ApplicationManagementException(msg, e);
             }
-        }
+        } else {
-        return existingDevices;
+            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 "
-    @Override
+                            + "type. Hence ignoring the device identifier. ");
-    public ApplicationInstallResponse installApplicationForUsers(String applicationUUID,
+                    continue;
-            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<Integer> operationTriggeredDeviceIds = new ArrayList<>();
-        List<DeviceIdentifier> installedDeviceIdentifiers = new ArrayList<>();
-        Map<Integer, DeviceSubscriptionDTO> deviceSubscriptions = new HashMap<>();
-
-        for (String user : userList) {
-            try {
-                List<Device> userDevices = HelperUtil.getDeviceManagementProviderService().getDevicesOfUser(user);
-                List<Integer> filteredDeviceIds = new ArrayList<>();
-                List<Device> filteredDevices = new ArrayList<>();
-
-                //todo improve for web clips
-                for (Device device : userDevices) {
-                    if (appDeviceType.getName().equals(device.getType())) {
-                        filteredDevices.add(device);
-                        filteredDeviceIds.add(device.getId());
-                    }
                 }
-                deviceSubscriptions = getDeviceSubscriptions(filteredDeviceIds);
+                validDeviceIDList.add(deviceIdentifier);
-                for (Device device : filteredDevices) {
-                    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())) {
-                        installedDeviceIdentifiers.add(deviceIdentifier);
-                    } else {
-                        compatibleDevices.put(deviceIdentifier, device.getId());
-                    }
-                }
-            } catch (DeviceManagementException e) {
-                String msg = "Error occurred when extracting the device list of user[" + user + "].";
-                log.error(msg);
-                throw new ApplicationManagementException(msg, e);
             }
         }
-        Activity activity = installToDevices(applicationDTO, new ArrayList<>(compatibleDevices.keySet()),
-                appDeviceType.getName());
 
-        List<ActivityStatus> activityStatuses = activity.getActivityStatus();
+        if (validDeviceIDList.isEmpty()) {
-        for (ActivityStatus status : activityStatuses) {
+            String msg = "Couldn't found at least one valid device identifier to install the application.";
-            if (status.getStatus().equals(ActivityStatus.Status.PENDING)){
+            log.error(msg);
-                operationTriggeredDeviceIds.add(compatibleDevices.get(status.getDeviceIdentifier()));
+            throw new BadRequestException(msg);
-            }
         }
-        ApplicationInstallResponse applicationInstallResponse = new ApplicationInstallResponse();
+        DeviceIDHolder deviceIDHolder = new DeviceIDHolder();
-        applicationInstallResponse.setActivity(activity);
+        deviceIDHolder.setValidDeviceIDList(validDeviceIDList);
-        applicationInstallResponse.setAlreadyInstalledDevices(installedDeviceIdentifiers);
+        deviceIDHolder.setErrorDeviceIdList(errorDeviceIdList);
-
+        return deviceIDHolder;
-//        int operationId = Integer
-//                .parseInt(activity.getActivityId().split(DeviceManagementConstants.OperationAttributes.ACTIVITY)[1]);
-        int operationId = Integer.parseInt(activity.getActivityId().split("ACTIVITY_")[1]);
-
-        addDeviceSubscriptions(applicationDTO.getApplicationReleaseDTOs().get(0).getId(),
-                operationTriggeredDeviceIds, new ArrayList<>(deviceSubscriptions.keySet()), userList, operationId, SubsciptionType.USER.toString());
-        return applicationInstallResponse;
     }
 
-    private void addDeviceSubscriptions(int applicationReleaseId, List<Integer> deviceIds,
+    private void addSubscriptions(int applicationReleaseId, Activity activity,
-            List<Integer> subDeviceIds, List<String> subscribers, int operationId, String subType)
+            Map<DeviceIdentifier, Integer> compatibleDevices, List<Integer> subDeviceIds, List<String> subscribers,
-            throws ApplicationManagementException {
+            String subType) throws ApplicationManagementException {
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true);
         String subscriber = PrivilegedCarbonContext.getThreadLocalCarbonContext().getUsername();
         try {
@@ -291,7 +339,7 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
             List<Integer> deviceResubscribingIds = new ArrayList<>();
             List<Integer> deviceSubscriptingIds;
 
-            if (SubsciptionType.USER.toString().equals(subType)){
+            if (SubsciptionType.USER.toString().equals(subType)) {
                 List<String> subscribedUsers = subscriptionDAO.getSubscribedUsernames(subscribers, tenantId);
                 if (!subscribedUsers.isEmpty()) {
                     subscriptionDAO
@@ -301,10 +349,20 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
                 subscriptionDAO.subscribeUserToApplication(tenantId, subscriber, subscribers, applicationReleaseId);
             }
 
+            //todo add for other subscription types
+
+            List<Integer> deviceIds = new ArrayList<>();
+            List<ActivityStatus> activityStatuses = activity.getActivityStatus();
+            for (ActivityStatus status : activityStatuses) {
+                if (status.getStatus().equals(ActivityStatus.Status.PENDING)) {
+                    deviceIds.add(compatibleDevices.get(status.getDeviceIdentifier()));
+                }
+            }
+
+            int operationId = Integer.parseInt(activity.getActivityId().split("ACTIVITY_")[1]);
             if (!subDeviceIds.isEmpty()) {
-                deviceResubscribingIds = subscriptionDAO
+                deviceResubscribingIds = subscriptionDAO.updateDeviceSubscription(subscriber, subDeviceIds, subType,
-                        .updateDeviceSubscription(subscriber, subDeviceIds, subType, Operation.Status.PENDING.toString(),
+                        Operation.Status.PENDING.toString(), applicationReleaseId, tenantId);
-                                applicationReleaseId, tenantId);
                 deviceIds.removeAll(subDeviceIds);
             }
             deviceSubscriptingIds = subscriptionDAO
@@ -315,8 +373,8 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
             ConnectionManagerUtil.commitDBTransaction();
         } catch (ApplicationManagementDAOException e) {
             ConnectionManagerUtil.rollbackDBTransaction();
-            String msg =
+            String msg = "Error occurred when adding subscription data for application release UUID: "
-                    "Error occurred when adding subscription data for application release UUID: " + applicationReleaseId;
+                    + applicationReleaseId;
             log.error(msg);
             throw new ApplicationManagementException(msg, e);
         } catch (DBConnectionException e) {
@@ -334,14 +392,13 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
         }
     }
 
-    private Map<Integer, DeviceSubscriptionDTO> getDeviceSubscriptions (List<Integer> filteredDeviceIds)
+    private Map<Integer, DeviceSubscriptionDTO> getDeviceSubscriptions(List<Integer> filteredDeviceIds)
             throws ApplicationManagementException {
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true);
 
         try {
             ConnectionManagerUtil.openDBConnection();
-            return this.subscriptionDAO
+            return this.subscriptionDAO.getDeviceSubscriptions(filteredDeviceIds, tenantId);
-                    .getDeviceSubscriptions(filteredDeviceIds, tenantId);
         } catch (ApplicationManagementDAOException e) {
             String msg = "Error occured when getting device subscriptions for given device IDs";
             log.error(msg);
@@ -356,9 +413,66 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
 
     }
 
-    @Override
+    //todo remove below methods
-    public ApplicationInstallResponseTmp installApplicationForRoles(String applicationUUID, List<String> roleList)
+
-            throws ApplicationManagementException {
+    @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.");
         }
@@ -400,9 +514,8 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
         return response;
     }
 
-    @Override
+    @Override public ApplicationInstallResponseTmp installApplicationForGroups(String applicationUUID,
-    public ApplicationInstallResponseTmp installApplicationForGroups(String applicationUUID, List<String> deviceGroupList)
+            List<String> deviceGroupList) throws ApplicationManagementException {
-            throws ApplicationManagementException {
         if (log.isDebugEnabled()) {
             log.debug("Install application: " + applicationUUID + " to " + deviceGroupList.size() + " groups.");
         }
@@ -452,25 +565,23 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
         return null;
     }
 
-    private Activity installToDevices(ApplicationDTO application,
+    private Activity addAppInstallOperationToDevices(ApplicationDTO application,
             List<DeviceIdentifier> deviceIdentifierList, String deviceType) throws ApplicationManagementException {
         DeviceManagementProviderService deviceManagementProviderService = HelperUtil
                 .getDeviceManagementProviderService();
         try {
             Operation operation = generateOperationPayloadByDeviceType(deviceType, application);
             //todo refactor add operation code to get successful operations
-            return deviceManagementProviderService
+            return deviceManagementProviderService.addOperation(deviceType, operation, deviceIdentifierList);
-                    .addOperation(deviceType, operation, deviceIdentifierList);
         } catch (OperationManagementException e) {
-            throw new ApplicationManagementException("Error occurred while adding the application install "
+            throw new ApplicationManagementException(
-                    + "operation to devices", e);
+                    "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");
         }
     }
 
-
     private ApplicationInstallResponseTmp installToDevicesTmp(ApplicationDTO application,
             List<DeviceIdentifier> deviceIdentifierList) throws ApplicationManagementException {
         DeviceManagementProviderService deviceManagementProviderService = HelperUtil
@@ -493,8 +604,8 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
             } catch (OperationManagementException e) {
                 response.setSuccessfulDevices(null);
                 response.setFailedDevices(deviceIdentifierList);
-                throw new ApplicationManagementException("Error occurred while adding the application install "
+                throw new ApplicationManagementException(
-                        + "operation to devices", e);
+                        "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");
@@ -541,7 +652,7 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
     /**
      * 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.
      *
@@ -572,5 +683,4 @@ public class SubscriptionManagerImpl implements SubscriptionManager {
         return applicationInstallResponseTmp;
     }
 
-
 }

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/util/Constants.java

@@ -65,4 +65,6 @@ public class Constants {
     public static final String RELEASE_ARTIFACT = "artifact";
 
     public static final int REVIEW_PARENT_ID = -1;
+
+    public static final int MAX_RATING = 5;
 }

components/application-mgt/org.wso2.carbon.device.application.mgt.store.api/src/main/java/org/wso2/carbon/device/application/mgt/store/api/services/ReviewManagementAPI.java

@@ -364,6 +364,10 @@ public interface ReviewManagementAPI {
                             message = "OK. \n Successfully retrieved ratings.",
                             response = List.class,
                             responseContainer = "List"),
+                    @ApiResponse(
+                            code = 404,
+                            message = "Not Found. \n No Application release found for application release UUID.",
+                            response = ErrorResponse.class),
                     @ApiResponse(
                             code = 500,
                             message = "Internal Server Error. \n Error occurred while getting ratings",

components/application-mgt/org.wso2.carbon.device.application.mgt.store.api/src/main/java/org/wso2/carbon/device/application/mgt/store/api/services/SubscriptionManagementAPI.java

@@ -128,6 +128,48 @@ public interface SubscriptionManagementAPI {
             @Valid List<DeviceIdentifier> deviceIdentifiers
     );
 
+    @POST
+    @Path("/install/{uuid}/{subType}")
+    @Produces(MediaType.APPLICATION_JSON)
+    @Consumes(MediaType.APPLICATION_JSON)
+    @ApiOperation(
+            consumes = MediaType.APPLICATION_JSON,
+            produces = MediaType.APPLICATION_JSON,
+            httpMethod = "POST",
+            value = "Install an application for subscription type.",
+            notes = "This will install an application to a given subscription type and this is bulk app installation.",
+            tags = "Subscription Management",
+            extensions = {
+                    @Extension(properties = {
+                            @ExtensionProperty(name = SCOPE, value = "perm:app:subscription:install")
+                    })
+            }
+    )
+    @ApiResponses(
+            value = {
+
+            })
+    Response addBulkAppInstalltion(
+            @ApiParam(
+                    name = "uuid",
+                    value = "The application release UUID",
+                    required = true
+            )
+            @PathParam("uuid") String uuid,
+            @ApiParam(
+                    name = "subType",
+                    value = "Subscription type of the app installing operation.",
+                    required = true
+            )
+            @PathParam("subType") String subType,
+            @ApiParam(
+                    name = "subscribers",
+                    value = "Subscriber list of the application release.",
+                    required = true
+            )
+            @Valid List<String> subscribers
+    );
+
     @POST
     @Path("/install/{uuid}/devices")
     @Produces(MediaType.APPLICATION_JSON)
@@ -402,238 +444,4 @@ public interface SubscriptionManagementAPI {
             )
             @Valid List<String> groups
     );
-
-
-
-
-
-
-
-
-
-//    ----------------------------------------------
-
-    @POST
-    @Path("/install-application")
-    @Produces(MediaType.APPLICATION_JSON)
-    @Consumes(MediaType.APPLICATION_JSON)
-    @ApiOperation(
-            consumes = MediaType.APPLICATION_JSON,
-            produces = MediaType.APPLICATION_JSON,
-            httpMethod = "POST",
-            value = "Install an application",
-            notes = "This will install an application to a given list of devices",
-            tags = "Subscription Management",
-            extensions = {
-                    @Extension(properties = {
-                            @ExtensionProperty(name = SCOPE, value = "perm:subscription:install")
-                    })
-            }
-    )
-    @ApiResponses(
-            value = {
-                    @ApiResponse(
-                            code = 200,
-                            message = "OK. \n Successfully sent the install application operation.",
-                            response = ApplicationInstallResponseTmp.class
-                    ),
-                    @ApiResponse(
-                            code = 304,
-                            message = "Not Modified. \n Empty body because the application is already installed."
-                    ),
-                    @ApiResponse(
-                            code = 404,
-                            message = "Not Found. \n ApplicationDTO cannot be found to install."
-                    ),
-                    @ApiResponse(
-                            code = 500,
-                            message = "Internal Server Error. \n Error occurred while installing the application."
-                    )
-            })
-    Response installApplication(
-            @ApiParam(
-                    name = "installationDetails",
-                    value = "The application ID and list of devices/users/roles",
-                    required = true
-            )
-            @Valid InstallationDetails installationDetails);
-
-    @POST
-    @Path("/enterprise-install-application")
-    @Produces(MediaType.APPLICATION_JSON)
-    @Consumes(MediaType.APPLICATION_JSON)
-    @ApiOperation(
-            consumes = MediaType.APPLICATION_JSON,
-            produces = MediaType.APPLICATION_JSON,
-            httpMethod = "POST",
-            value = "Install an application to the devices belong to an enterprise entity",
-            notes = "This will install an application to a given list of groups/users/roles",
-            tags = "Subscription Management",
-            extensions = {
-                    @Extension(properties = {
-                            @ExtensionProperty(name = SCOPE, value = "perm:subscription:install")
-                    })
-            }
-    )
-    @ApiResponses(
-            value = {
-                    @ApiResponse(
-                            code = 200,
-                            message = "OK. \n Successfully sent the install application operation.",
-                            response = ApplicationInstallResponseTmp.class
-                    ),
-                    @ApiResponse(
-                            code = 304,
-                            message = "Not Modified. \n Empty body because the application is already installed."
-                    ),
-                    @ApiResponse(
-                            code = 404,
-                            message = "Not Found. \n ApplicationDTO cannot be found to install."
-                    ),
-                    @ApiResponse(
-                            code = 500,
-                            message = "Internal Server Error. \n Error occurred while installing the application."
-                    )
-            })
-    Response enterpriseInstallApplication(
-            @ApiParam(
-                    name = "enterpriseInstallationDetails",
-                    value = "The application ID and list of devices/users/roles",
-                    required = true)
-            @Valid EnterpriseInstallationDetails enterpriseInstallationDetails);
-
-    @POST
-    @Path("/uninstall-application")
-    @Produces(MediaType.APPLICATION_JSON)
-    @Consumes(MediaType.APPLICATION_JSON)
-    @ApiOperation(
-            consumes = MediaType.APPLICATION_JSON,
-            produces = MediaType.APPLICATION_JSON,
-            httpMethod = "POST",
-            value = "Uninstall an application",
-            notes = "This will uninstall an application from given list of devices",
-            tags = "Subscription Management",
-            extensions = {
-                    @Extension(properties = {
-                            @ExtensionProperty(name = SCOPE, value = "perm:subscription:uninstall")
-                    })
-            }
-    )
-    @ApiResponses(
-            value = {
-                    @ApiResponse(
-                            code = 200,
-                            message = "OK. \n Successfully uninstalled the application.",
-                            response = ApplicationDTO.class
-                    ),
-                    @ApiResponse(
-                            code = 304,
-                            message = "Not Modified. \n Empty body because the application is already uninstalled."
-                    ),
-                    @ApiResponse(
-                            code = 404,
-                            message = "Not Found. \n ApplicationDTO cannot be found to uninstall."
-                    ),
-                    @ApiResponse(
-                            code = 500,
-                            message = "Internal Server Error. \n Error occurred while uninstalling the application."
-                    )
-            })
-    Response uninstallApplication(
-            @ApiParam(
-                    name = "installationDetails",
-                    value = "The application ID and list of devices",
-                    required = true)
-            @Valid InstallationDetails installationDetails);
-
-    @POST
-    @Path("/enterprise-uninstall-application")
-    @Produces(MediaType.APPLICATION_JSON)
-    @Consumes(MediaType.APPLICATION_JSON)
-    @ApiOperation(
-            consumes = MediaType.APPLICATION_JSON,
-            produces = MediaType.APPLICATION_JSON,
-            httpMethod = "POST",
-            value = "Uninstall an application from the devices belong to an enterprise entity",
-            notes = "This will uninstall an application from devices belong to given list of groups/users/roles",
-            tags = "Subscription Management",
-            extensions = {
-                    @Extension(properties = {
-                            @ExtensionProperty(name = SCOPE, value = "perm:subscription:uninstall")
-                    })
-            }
-    )
-    @ApiResponses(
-            value = {
-                    @ApiResponse(
-                            code = 200,
-                            message = "OK. \n Successfully uninstalled the application.",
-                            response = ApplicationDTO.class
-                    ),
-                    @ApiResponse(
-                            code = 304,
-                            message = "Not Modified. \n Empty body because the application is already uninstalled."
-                    ),
-                    @ApiResponse(
-                            code = 404,
-                            message = "Not Found. \n ApplicationDTO cannot be found to uninstall."
-                    ),
-                    @ApiResponse(
-                            code = 500,
-                            message = "Internal Server Error. \n Error occurred while uninstalling the application."
-                    )
-            })
-    Response enterpriseUninstallApplication(
-            @ApiParam(
-                    name = "enterpriseInstallationDetails",
-                    value = "The application ID and list of groups/users/roles",
-                    required = true
-            )
-            @Valid EnterpriseInstallationDetails enterpriseInstallationDetails);
-
-    @GET
-    @Path("/application/{applicationUUID}/device/{deviceId}")
-    @Produces(MediaType.APPLICATION_JSON)
-    @Consumes(MediaType.APPLICATION_JSON)
-    @ApiOperation(
-            consumes = MediaType.APPLICATION_JSON,
-            produces = MediaType.APPLICATION_JSON,
-            httpMethod = "GET",
-            value = "Get an application",
-            notes = "This will return an application to a given valid token",
-            tags = "Subscription Management",
-            extensions = {
-                    @Extension(properties = {
-                            @ExtensionProperty(name = SCOPE, value = "perm:subscription:getApplication")
-                    })
-            }
-    )
-    @ApiResponses(
-            value = {
-                    @ApiResponse(
-                            code = 200,
-                            message = "OK. \n Successfully installed the application.",
-                            response = ApplicationDTO.class
-                    ),
-                    @ApiResponse(
-                            code = 304,
-                            message = "Not Modified. \n " +
-                                    "Empty body because the application is already installed."
-                    ),
-                    @ApiResponse(
-                            code = 500,
-                            message = "Internal Server Error. \n Error occurred while fetching the application."
-                    )
-            })
-    Response getApplication(
-            @ApiParam(
-                    name = "applicationUUID",
-                    value = "ApplicationDTO ID"
-            )
-            @QueryParam("applicationUUID") String applicationUUID,
-            @ApiParam(
-                    name = "deviceId",
-                    value = "The device ID"
-            )
-            @QueryParam("deviceId") String deviceId);
 }

components/application-mgt/org.wso2.carbon.device.application.mgt.store.api/src/main/java/org/wso2/carbon/device/application/mgt/store/api/services/impl/ReviewManagementAPIImpl.java

@@ -234,8 +234,13 @@ public class ReviewManagementAPIImpl implements ReviewManagementAPI {
         Rating rating;
         try {
             rating = reviewManager.getRating(uuid);
-        } catch (ReviewManagementException e) {
+        } catch (NotFoundException e) {
-            log.error("Review Management Exception occurs", e);
+            String msg = "Couldn't found an application release for UUID: " + uuid;
+            log.error(msg, e);
+            return Response.status(Response.Status.NOT_FOUND).entity(msg).build();
+        } catch (ReviewManagementException | ApplicationManagementException e) {
+            String msg = "Error occured while getting review data for application release UUID: " + uuid;
+            log.error(msg, e);
             return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
         }
         return Response.status(Response.Status.OK).entity(rating).build();

components/application-mgt/org.wso2.carbon.device.application.mgt.store.api/src/main/java/org/wso2/carbon/device/application/mgt/store/api/services/impl/SubscriptionManagementAPIImpl.java

@@ -88,6 +88,39 @@ public class SubscriptionManagementAPIImpl implements SubscriptionManagementAPI{
         }
     }
 
+    @Override
+    @POST
+    @Path("/install/{uuid}/{subType}")
+    public Response addBulkAppInstalltion(
+            @PathParam("uuid") String uuid,
+            @PathParam("uuid") String subType,
+            @Valid List<String> subscribers) {
+        try {
+            SubscriptionManager subscriptionManager = APIUtil.getSubscriptionManager();
+            ApplicationInstallResponse response = subscriptionManager.addBulkApInstallation(uuid, subscribers, subType);
+            return Response.status(Response.Status.OK).entity(response).build();
+        } catch (NotFoundException e) {
+            String msg = "Couldn't found an application release for UUID: " + uuid + ". Hence, verify the payload";
+            log.error(msg);
+            return Response.status(Response.Status.NOT_FOUND).entity(msg).build();
+        } catch (BadRequestException e) {
+            String msg = "Found invalid payload for installing application which has UUID: " + uuid
+                    + ". Hence verify the payload";
+            log.error(msg);
+            return Response.status(Response.Status.BAD_REQUEST).entity(msg).build();
+        } catch (ForbiddenException e) {
+            String msg = "Application release is not in the installable state. Hence you are not permitted to install "
+                    + "the application.";
+            log.error(msg);
+            return Response.status(Response.Status.FORBIDDEN).entity(msg).build();
+        } catch (ApplicationManagementException e) {
+            String msg = "Error occurred while installing the application release which has UUID: " + uuid
+                    + " for user devices";
+            log.error(msg);
+            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(msg).build();
+        }
+    }
+
     @Override
     @POST
     @Path("/install/{uuid}/users")
@@ -182,99 +215,4 @@ public class SubscriptionManagementAPIImpl implements SubscriptionManagementAPI{
 
     }
 
-
-
-
-
-
-
-
-    @Override
-    @POST
-    @Path("/install-application")
-    public Response installApplication(@ApiParam(name = "installationDetails", value = "ApplicationDTO ID and list of" +
-            "devices", required = true) @Valid InstallationDetails installationDetails) {
-        SubscriptionManager subscriptionManager = APIUtil.getSubscriptionManager();
-        String applicationUUID = installationDetails.getApplicationUUID();
-
-        if (applicationUUID.isEmpty() || installationDetails.getDeviceIdentifiers().isEmpty()) {
-            String msg = "Some or all data in the incoming request is empty. Therefore unable to proceed with the "
-                    + "installation.";
-            log.error(msg);
-            return Response.status(Response.Status.BAD_REQUEST).entity(msg).build();
-        }
-
-        try {
-            ApplicationInstallResponse response = subscriptionManager.installApplicationForDevices(applicationUUID,
-                    installationDetails.getDeviceIdentifiers());
-            return Response.status(Response.Status.OK).entity(response).build();
-        } catch (ApplicationManagementException e) {
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-                    .entity("Error occurred while installing the application for devices" + ": " + e.getMessage())
-                    .build();
-        }
-    }
-
-    @Override
-    public Response enterpriseInstallApplication(EnterpriseInstallationDetails enterpriseInstallationDetails) {
-        SubscriptionManager subscriptionManager = APIUtil.getSubscriptionManager();
-        String msg;
-        String applicationUUID = enterpriseInstallationDetails.getApplicationUUID();
-        EnterpriseInstallationDetails.EnterpriseEntity enterpriseEntity = enterpriseInstallationDetails.getEntityType();
-        List<String> entityValueList = enterpriseInstallationDetails.getEntityValueList();
-        ApplicationInstallResponseTmp response = null;
-
-        if (applicationUUID.isEmpty()) {
-            msg = "ApplicationDTO UUID is empty in the incoming request. Therefore unable to proceed with the "
-                    + "installation.";
-            log.error(msg);
-            return Response.status(Response.Status.BAD_REQUEST).entity(msg).build();
-        }
-
-        if (enterpriseEntity == null || entityValueList.isEmpty()) {
-            msg = "Some or all details of the entity is empty in the incoming request. Therefore unable to proceed "
-                    + "with the installation.";
-            log.error(msg);
-            return Response.status(Response.Status.BAD_REQUEST).entity(msg).build();
-        }
-
-        try {
-            if (EnterpriseInstallationDetails.EnterpriseEntity.USER.equals(enterpriseEntity)) {
-//                response = subscriptionManager.installApplicationForUsers(applicationUUID, entityValueList);
-            } else if (EnterpriseInstallationDetails.EnterpriseEntity.ROLE.equals(enterpriseEntity)) {
-                response = subscriptionManager.installApplicationForRoles(applicationUUID, entityValueList);
-            } else if (EnterpriseInstallationDetails.EnterpriseEntity.DEVICE_GROUP.equals(enterpriseEntity)) {
-                response = subscriptionManager.installApplicationForGroups(applicationUUID, entityValueList);
-            } else {
-                msg = "Entity type does not match either USER, ROLE or DEVICE_GROUP. Therefore unable to proceed with "
-                        + "the installation";
-                log.error(msg);
-                return Response.status(Response.Status.BAD_REQUEST).entity(msg).build();
-            }
-            return Response.status(Response.Status.OK).entity(response).build();
-        } catch (ApplicationManagementException e) {
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-                    .entity("Error occurred while installing the application for devices" + ": " + e.getMessage())
-                    .build();
-        }
-    }
-
-    @Override
-    public Response uninstallApplication(@ApiParam(name = "installationDetails", value = "The application ID and list" +
-            " of devices/users/roles", required = true) @Valid InstallationDetails installationDetails) {
-        return null;
-    }
-
-    @Override
-    public Response enterpriseUninstallApplication(
-            EnterpriseInstallationDetails enterpriseInstallationDetails) {
-        return null;
-    }
-
-    @Override
-    public Response getApplication(@ApiParam(name = "applicationUUID", value = "ApplicationDTO ID") String
-                                               applicationUUID, @ApiParam(name = "deviceId", value = "The device ID")
-            String deviceId) {
-        return null;
-    }
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/dao/GroupDAO.java

@@ -190,6 +190,8 @@ public interface GroupDAO {
     List<Device> getDevices(int groupId, int startIndex, int rowCount, int tenantId)
             throws GroupManagementDAOException;
 
+    List<Device> getAllDevicesOfGroup(String groupName, int tenantId) throws GroupManagementDAOException;
+
     /**
      * Get all user roles for device group.
      *

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/dao/impl/AbstractGroupDAOImpl.java

@@ -18,11 +18,13 @@
 
 package org.wso2.carbon.device.mgt.core.dao.impl;
 
+import org.wso2.carbon.device.mgt.common.Device;
 import org.wso2.carbon.device.mgt.common.GroupPaginationRequest;
 import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroup;
 import org.wso2.carbon.device.mgt.core.dao.GroupDAO;
 import org.wso2.carbon.device.mgt.core.dao.GroupManagementDAOException;
 import org.wso2.carbon.device.mgt.core.dao.GroupManagementDAOFactory;
+import org.wso2.carbon.device.mgt.core.dao.util.DeviceManagementDAOUtil;
 import org.wso2.carbon.device.mgt.core.dao.util.GroupManagementDAOUtil;
 
 import java.sql.Connection;
@@ -619,4 +621,53 @@ public abstract class AbstractGroupDAOImpl implements GroupDAO {
         }
     }
 
+    @Override
+    public List<Device> getAllDevicesOfGroup(String groupName, int tenantId) throws GroupManagementDAOException {
+        Connection conn;
+        List<Device> devices;
+        try {
+            conn = GroupManagementDAOFactory.getConnection();
+            String sql = "SELECT "
+                    + "d1.DEVICE_ID, "
+                    + "d1.DESCRIPTION, "
+                    + "d1.NAME AS DEVICE_NAME, "
+                    + "d1.DEVICE_TYPE, "
+                    + "d1.DEVICE_IDENTIFICATION, "
+                    + "e.OWNER, "
+                    + "e.OWNERSHIP, "
+                    + "e.STATUS, "
+                    + "e.DATE_OF_LAST_UPDATE, "
+                    + "e.DATE_OF_ENROLMENT, "
+                    + "e.ID AS ENROLMENT_ID "
+                    + "FROM "
+                    + "DM_ENROLMENT e, "
+                    + "(SELECT gd.DEVICE_ID, gd.DESCRIPTION, gd.NAME, gd.DEVICE_IDENTIFICATION, t.NAME AS DEVICE_TYPE "
+                    + "FROM "
+                    + "(SELECT d.ID AS DEVICE_ID, d.DESCRIPTION, d.NAME, d.DEVICE_IDENTIFICATION, d.DEVICE_TYPE_ID "
+                    + "FROM DM_DEVICE d, "
+                    + "(SELECT dgm.DEVICE_ID "
+                    + "FROM DM_DEVICE_GROUP_MAP dgm "
+                    + "WHERE dgm.GROUP_ID = (SELECT ID FROM DM_GROUP WHERE GROUP_NAME = ? )) dgm1 "
+                    + "WHERE d.ID = dgm1.DEVICE_ID AND d.TENANT_ID = ?) gd, DM_DEVICE_TYPE t "
+                    + "WHERE gd.DEVICE_TYPE_ID = t.ID) d1 "
+                    + "WHERE d1.DEVICE_ID = e.DEVICE_ID AND TENANT_ID = ?";
+
+            try (PreparedStatement stmt = conn.prepareStatement(sql)){
+                stmt.setString(1, groupName);
+                stmt.setInt(2, tenantId);
+                stmt.setInt(3, tenantId);
+                try (ResultSet rs = stmt.executeQuery() ){
+                    devices = new ArrayList<>();
+                    while (rs.next()) {
+                        Device device = DeviceManagementDAOUtil.loadDevice(rs);
+                        devices.add(device);
+                    }
+                }
+            }
+        } catch (SQLException e) {
+            throw new GroupManagementDAOException("Error occurred while retrieving information of all registered devices"
+                    + " which belongs to the given group name.", e);
+        }
+        return devices;
+    }
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/operation/mgt/OperationManagerImpl.java

@@ -171,8 +171,6 @@ public class OperationManagerImpl implements OperationManager {
                         + PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantDomain() + ", device count:"
                         + deviceIds.size() + " operation type:" + operation.getCode());
             }
-//            Map<Integer, List<DeviceIdentifier>> ignoredDeviceIdentifierMap = new HashMap<>();
-//            Map<Integer, List<DeviceIdentifier>> authorizedDeviceIdentifierMap = new HashMap<>();
             DeviceIDHolder deviceAuthorizationResult = this.authorizeDevices(operation, validDeviceIds);
             List<DeviceIdentifier> authorizedDeviceIds = deviceAuthorizationResult.getValidDeviceIDList();
             if (authorizedDeviceIds.isEmpty()) {
@@ -221,17 +219,6 @@ public class OperationManagerImpl implements OperationManager {
                         ignoredDevices.add(device);
                         operation.setId(existingOperationID);
                         this.sendNotification(operation, device);
-//                        List<DeviceIdentifier> deviceIdentifiers;
-//                        if (ignoredDeviceIdentifierMap.containsKey(existingOperationID)) {
-//                            deviceIdentifiers = ignoredDeviceIdentifierMap.get(existingOperationID);
-//                        } else {
-//                            deviceIdentifiers = new ArrayList<>();
-//                        }
-//                        DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
-//                        deviceIdentifier.setType(device.getType());
-//                        deviceIdentifier.setId(device.getDeviceIdentifier());
-//                        deviceIdentifiers.add(deviceIdentifier);
-//                        ignoredDeviceIdentifierMap.put(existingOperationID, deviceIdentifiers);
                     }
                 }
             }
@@ -266,20 +253,12 @@ public class OperationManagerImpl implements OperationManager {
             }
 
             //TODO have to create a sql to load device details from deviceDAO using single query.
-            List<DeviceIdentifier> authorizedDeviceIdentifiers = new ArrayList<>();
             for (Device device : authorizedDevices) {
                 enrolmentId = device.getEnrolmentInfo().getId();
                 //Do not repeat the task operations
                 operationMappingDAO.addOperationMapping(operationId, enrolmentId, isScheduled);
-//                DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
-//                deviceIdentifier.setId(device.getDeviceIdentifier());
-//                deviceIdentifier.setType(device.getType());
-//                authorizedDeviceIdentifiers.add(deviceIdentifier);
             }
-
-//            authorizedDeviceIdentifierMap.put(operationId, authorizedDeviceIdentifiers);
             OperationManagementDAOFactory.commitTransaction();
-
             if (!isScheduled) {
                 for (Device device : authorizedDevices) {
                     this.sendNotification(operation, device);

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/operation/mgt/OperationMgtConstants.java

@@ -20,13 +20,6 @@ package org.wso2.carbon.device.mgt.core.operation.mgt;
 
 public class OperationMgtConstants {
 
-    public final class DeviceConstants {
-        private DeviceConstants() {
-        }
-
-        public static final String DEVICE_ID_NOT_FOUND = "Device not found for device id: %s";
-    }
-
     public final class OperationCodes {
         private OperationCodes() {
         }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/service/GroupManagementProviderService.java

@@ -166,6 +166,9 @@ public interface GroupManagementProviderService {
      */
     List<Device> getDevices(int groupId, int startIndex, int rowCount) throws GroupManagementException;
 
+    List<Device> getAllDevicesOfGroup(String groupName) throws GroupManagementException;
+
+
     /**
      * This method is used to retrieve the device count of a given group.
      *

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/service/GroupManagementProviderServiceImpl.java

@@ -619,6 +619,30 @@ public class GroupManagementProviderServiceImpl implements GroupManagementProvid
         return devices;
     }
 
+    public List<Device> getAllDevicesOfGroup(String groupName) throws GroupManagementException {
+
+        if (log.isDebugEnabled()) {
+            log.debug("Group devices of group: " + groupName);
+        }
+        int tenantId = CarbonContext.getThreadLocalCarbonContext().getTenantId();
+        List<Device> devices;
+        try {
+            GroupManagementDAOFactory.openConnection();
+            devices = this.groupDAO.getAllDevicesOfGroup(groupName, tenantId);
+        } catch (GroupManagementDAOException | SQLException e) {
+            String msg = "Error occurred while getting devices in group.";
+            log.error(msg, e);
+            throw new GroupManagementException(msg, e);
+        } catch (Exception e) {
+            String msg = "Error occurred in getDevices for group name: " + groupName;
+            log.error(msg, e);
+            throw new GroupManagementException(msg, e);
+        } finally {
+            GroupManagementDAOFactory.closeConnection();
+        }
+        return devices;
+    }
+
     /**
      * {@inheritDoc}
      */

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/util/DeviceManagerUtil.java

@@ -463,25 +463,16 @@ public final class DeviceManagerUtil {
     }
 
     public static DeviceIDHolder validateDeviceIdentifiers(List<DeviceIdentifier> deviceIDs) {
-
         List<DeviceIdentifier> errorDeviceIdList = new ArrayList<>();
         List<DeviceIdentifier> validDeviceIDList = new ArrayList<>();
-
-        int deviceIDCounter = 0;
         for (DeviceIdentifier deviceIdentifier : deviceIDs) {
-
-            deviceIDCounter++;
             String deviceID = deviceIdentifier.getId();
-
             if (deviceID == null || deviceID.isEmpty()) {
-                log.warn(String.format(OperationMgtConstants.DeviceConstants.DEVICE_ID_NOT_FOUND,
+                log.warn("When adding operation for devices, found a device identifiers which doesn't have defined "
-                        deviceIDCounter));
+                        + "the identity of the device, with the request. Hence ignoring the device identifier.");
-                errorDeviceIdList.add(deviceIdentifier);
                 continue;
             }
-
             try {
-
                 if (isValidDeviceIdentifier(deviceIdentifier)) {
                     validDeviceIDList.add(deviceIdentifier);
                 } else {
@@ -491,7 +482,6 @@ public final class DeviceManagerUtil {
                 errorDeviceIdList.add(deviceIdentifier);
             }
         }
-
         DeviceIDHolder deviceIDHolder = new DeviceIDHolder();
         deviceIDHolder.setValidDeviceIDList(validDeviceIDList);
         deviceIDHolder.setErrorDeviceIdList(errorDeviceIdList);
@@ -505,10 +495,8 @@ public final class DeviceManagerUtil {
         if (device == null || device.getDeviceIdentifier() == null ||
                 device.getDeviceIdentifier().isEmpty() || device.getEnrolmentInfo() == null) {
             return false;
-        } else if (EnrolmentInfo.Status.REMOVED.equals(device.getEnrolmentInfo().getStatus())) {
+        } else
-            return false;
+            return !EnrolmentInfo.Status.REMOVED.equals(device.getEnrolmentInfo().getStatus());
-        }
-        return true;
     }
 
     public static boolean isDeviceExists(DeviceIdentifier deviceIdentifier) throws DeviceManagementException {