Improvements for subscription details view

components/application-mgt/io.entgra.device.mgt.core.application.mgt.common/src/main/java/io/entgra/device/mgt/core/application/mgt/common/DeviceSubscription.java

@@ -0,0 +1,77 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.common;
+
+public class DeviceSubscription {
+    private String deviceIdentifier;
+    private String deviceStatus;
+    private String deviceOwner;
+    private String deviceType;
+    private String ownershipType;
+    private SubscriptionData subscriptionData;
+
+    public String getDeviceIdentifier() {
+        return deviceIdentifier;
+    }
+
+    public void setDeviceIdentifier(String deviceIdentifier) {
+        this.deviceIdentifier = deviceIdentifier;
+    }
+
+    public String getDeviceStatus() {
+        return deviceStatus;
+    }
+
+    public void setDeviceStatus(String deviceStatus) {
+        this.deviceStatus = deviceStatus;
+    }
+
+    public String getDeviceOwner() {
+        return deviceOwner;
+    }
+
+    public void setDeviceOwner(String deviceOwner) {
+        this.deviceOwner = deviceOwner;
+    }
+
+    public String getDeviceType() {
+        return deviceType;
+    }
+
+    public void setDeviceType(String deviceType) {
+        this.deviceType = deviceType;
+    }
+
+    public String getOwnershipType() {
+        return ownershipType;
+    }
+
+    public void setOwnershipType(String ownershipType) {
+        this.ownershipType = ownershipType;
+    }
+
+    public SubscriptionData getSubscriptionData() {
+        return subscriptionData;
+    }
+
+    public void setSubscriptionData(SubscriptionData subscriptionData) {
+        this.subscriptionData = subscriptionData;
+    }
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.common/src/main/java/io/entgra/device/mgt/core/application/mgt/common/DeviceSubscriptionFilterCriteria.java

@@ -0,0 +1,68 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.common;
+
+public class DeviceSubscriptionFilterCriteria {
+    private String name;
+    private String owner;
+    private String deviceStatus;
+    private String filteringDeviceSubscriptionStatus; // COMPLETE, PENDING ...
+    private String triggeredBy;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getOwner() {
+        return owner;
+    }
+
+    public void setOwner(String owner) {
+        this.owner = owner;
+    }
+
+    public String getDeviceStatus() {
+        return deviceStatus;
+    }
+
+    public void setDeviceStatus(String deviceStatus) {
+        this.deviceStatus = deviceStatus;
+    }
+
+    public String getFilteringDeviceSubscriptionStatus() {
+        return filteringDeviceSubscriptionStatus;
+    }
+
+    public void setFilteringDeviceSubscriptionStatus(String filteringDeviceSubscriptionStatus) {
+        this.filteringDeviceSubscriptionStatus = filteringDeviceSubscriptionStatus;
+    }
+
+    public String getTriggeredBy() {
+        return triggeredBy;
+    }
+
+    public void setTriggeredBy(String triggeredBy) {
+        this.triggeredBy = triggeredBy;
+    }
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.common/src/main/java/io/entgra/device/mgt/core/application/mgt/common/SubscriptionData.java

@@ -0,0 +1,61 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.common;
+
+import java.sql.Timestamp;
+
+public class SubscriptionData {
+    private String deviceSubscriptionStatus;
+    private String triggeredBy;
+    private String subscriptionType;
+    private Timestamp triggeredAt;
+
+    public String getDeviceSubscriptionStatus() {
+        return deviceSubscriptionStatus;
+    }
+
+    public void setDeviceSubscriptionStatus(String deviceSubscriptionStatus) {
+        this.deviceSubscriptionStatus = deviceSubscriptionStatus;
+    }
+
+    public String getTriggeredBy() {
+        return triggeredBy;
+    }
+
+    public void setTriggeredBy(String triggeredBy) {
+        this.triggeredBy = triggeredBy;
+    }
+
+    public String getSubscriptionType() {
+        return subscriptionType;
+    }
+
+    public void setSubscriptionType(String subscriptionType) {
+        this.subscriptionType = subscriptionType;
+    }
+
+    public Timestamp getTriggeredAt() {
+        return triggeredAt;
+    }
+
+    public void setTriggeredAt(Timestamp triggeredAt) {
+        this.triggeredAt = triggeredAt;
+    }
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.common/src/main/java/io/entgra/device/mgt/core/application/mgt/common/SubscriptionEntity.java

@@ -0,0 +1,88 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.common;
+
+import java.sql.Timestamp;
+
+public class SubscriptionEntity {
+    private String identity;
+    private String subscribedBy;
+    private Timestamp subscribedTimestamp;
+    private boolean unsubscribed;
+    private String unsubscribedBy;
+    private Timestamp unsubscribedTimestamp;
+    private int applicationReleaseId;
+
+    public String getIdentity() {
+        return identity;
+    }
+
+    public void setIdentity(String identity) {
+        this.identity = identity;
+    }
+
+    public String getSubscribedBy() {
+        return subscribedBy;
+    }
+
+    public void setSubscribedBy(String subscribedBy) {
+        this.subscribedBy = subscribedBy;
+    }
+
+    public Timestamp getSubscribedTimestamp() {
+        return subscribedTimestamp;
+    }
+
+    public void setSubscribedTimestamp(Timestamp subscribedTimestamp) {
+        this.subscribedTimestamp = subscribedTimestamp;
+    }
+
+    public boolean getUnsubscribed() {
+        return unsubscribed;
+    }
+
+    public void setUnsubscribed(boolean unsubscribed) {
+        this.unsubscribed = unsubscribed;
+    }
+
+    public String getUnsubscribedBy() {
+        return unsubscribedBy;
+    }
+
+    public void setUnsubscribedBy(String unsubscribedBy) {
+        this.unsubscribedBy = unsubscribedBy;
+    }
+
+    public Timestamp getUnsubscribedTimestamp() {
+        return unsubscribedTimestamp;
+    }
+
+    public void setUnsubscribedTimestamp(Timestamp unsubscribedTimestamp) {
+        this.unsubscribedTimestamp = unsubscribedTimestamp;
+    }
+
+    public int getApplicationReleaseId() {
+        return applicationReleaseId;
+    }
+
+    public void setApplicationReleaseId(int applicationReleaseId) {
+        this.applicationReleaseId = applicationReleaseId;
+    }
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.common/src/main/java/io/entgra/device/mgt/core/application/mgt/common/SubscriptionInfo.java

@@ -0,0 +1,77 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.common;
+
+public class SubscriptionInfo {
+    private String applicationUUID;
+    private String subscriptionType;
+    private String deviceSubscriptionStatus;
+    private String identifier;
+    private String subscriptionStatus;
+    private DeviceSubscriptionFilterCriteria deviceSubscriptionFilterCriteria;
+
+    public String getApplicationUUID() {
+        return applicationUUID;
+    }
+
+    public void setApplicationUUID(String applicationUUID) {
+        this.applicationUUID = applicationUUID;
+    }
+
+    public String getSubscriptionType() {
+        return subscriptionType;
+    }
+
+    public void setSubscriptionType(String subscriptionType) {
+        this.subscriptionType = subscriptionType;
+    }
+
+    public String getDeviceSubscriptionStatus() {
+        return deviceSubscriptionStatus;
+    }
+
+    public void setDeviceSubscriptionStatus(String deviceSubscriptionStatus) {
+        this.deviceSubscriptionStatus = deviceSubscriptionStatus;
+    }
+
+    public String getIdentifier() {
+        return identifier;
+    }
+
+    public void setIdentifier(String identifier) {
+        this.identifier = identifier;
+    }
+
+    public String getSubscriptionStatus() {
+        return subscriptionStatus;
+    }
+
+    public void setSubscriptionStatus(String subscriptionStatus) {
+        this.subscriptionStatus = subscriptionStatus;
+    }
+
+    public DeviceSubscriptionFilterCriteria getDeviceSubscriptionFilterCriteria() {
+        return deviceSubscriptionFilterCriteria;
+    }
+
+    public void setDeviceSubscriptionFilterCriteria(DeviceSubscriptionFilterCriteria deviceSubscriptionFilterCriteria) {
+        this.deviceSubscriptionFilterCriteria = deviceSubscriptionFilterCriteria;
+    }
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.common/src/main/java/io/entgra/device/mgt/core/application/mgt/common/dto/DeviceSubscriptionDTO.java

@@ -19,6 +19,7 @@
 package io.entgra.device.mgt.core.application.mgt.common.dto;
 
 import java.sql.Timestamp;
+import java.util.Objects;
 
 public class DeviceSubscriptionDTO {
 
@@ -34,6 +35,19 @@ public class DeviceSubscriptionDTO {
     private int appReleaseId;
     private String appUuid;
 
+    public DeviceSubscriptionDTO() {
+
+    }
+
+    public DeviceSubscriptionDTO(int deviceId) {
+        this.deviceId = deviceId;
+    }
+
+    public DeviceSubscriptionDTO(int deviceId, String status) {
+        this.deviceId = deviceId;
+        this.status = status;
+    }
+
     public int getId() {
         return id;
     }
@@ -121,4 +135,17 @@ public class DeviceSubscriptionDTO {
     public void setAppUuid(String appUuid) {
         this.appUuid = appUuid;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        DeviceSubscriptionDTO that = (DeviceSubscriptionDTO) o;
+        return deviceId == that.deviceId;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(deviceId);
+    }
 }

components/application-mgt/io.entgra.device.mgt.core.application.mgt.common/src/main/java/io/entgra/device/mgt/core/application/mgt/common/services/SubscriptionManager.java

@@ -19,9 +19,14 @@ package io.entgra.device.mgt.core.application.mgt.common.services;
 
 import io.entgra.device.mgt.core.application.mgt.common.ApplicationInstallResponse;
 import io.entgra.device.mgt.core.application.mgt.common.CategorizedSubscriptionResult;
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscription;
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscriptionData;
 import io.entgra.device.mgt.core.application.mgt.common.ExecutionStatus;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionEntity;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionInfo;
 import io.entgra.device.mgt.core.application.mgt.common.SubscriptionType;
 import io.entgra.device.mgt.core.application.mgt.common.dto.CategorizedSubscriptionCountsDTO;
+import io.entgra.device.mgt.core.application.mgt.common.dto.DeviceSubscriptionDTO;
 import io.entgra.device.mgt.core.application.mgt.common.dto.ScheduledSubscriptionDTO;
 import io.entgra.device.mgt.core.application.mgt.common.dto.SubscriptionsDTO;
 import io.entgra.device.mgt.core.application.mgt.common.dto.DeviceOperationDTO;
@@ -260,8 +265,13 @@ public interface SubscriptionManager {
      * @return {@link SubscriptionsDTO} which contains the details of subscriptions.
      * @throws ApplicationManagementException if an error occurs while fetching the role details
      */
-    List<SubscriptionsDTO> getRoleSubscriptionsByUUID(String uuid, String subscriptionStatus, PaginationRequest request,
+//    List<SubscriptionsDTO> getRoleSubscriptionsByUUID(String uuid, String subscriptionStatus, PaginationRequest request,
-                                                      int offset, int limit) throws ApplicationManagementException;
+//                                                      int offset, int limit) throws ApplicationManagementException;
+    List<SubscriptionEntity> getSubscriptions(SubscriptionInfo subscriptionInfo, int limit, int offset)
+            throws ApplicationManagementException;
+
+    List<DeviceSubscription> getStatusBaseSubscriptions(SubscriptionInfo subscriptionInfo, int limit, int offset)
+            throws ApplicationManagementException;
 
     /**
      * Retrieves the Device Subscription details associated with a given app release UUID.

components/application-mgt/io.entgra.device.mgt.core.application.mgt.core/src/main/java/io/entgra/device/mgt/core/application/mgt/core/dao/SubscriptionDAO.java

@@ -19,6 +19,7 @@ package io.entgra.device.mgt.core.application.mgt.core.dao;
 
 import io.entgra.device.mgt.core.application.mgt.common.ExecutionStatus;
 import io.entgra.device.mgt.core.application.mgt.common.dto.GroupSubscriptionDTO;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionEntity;
 import io.entgra.device.mgt.core.application.mgt.common.dto.SubscriptionsDTO;
 import io.entgra.device.mgt.core.application.mgt.common.dto.DeviceSubscriptionDTO;
 import io.entgra.device.mgt.core.application.mgt.common.dto.ApplicationReleaseDTO;
@@ -327,7 +328,7 @@ public interface SubscriptionDAO {
      * @return {@link GroupSubscriptionDTO} which contains the details of group subscriptions.
      * @throws ApplicationManagementDAOException if connection establishment fails.
      */
-    List<GroupSubscriptionDTO> getGroupsSubscriptionDetailsByAppReleaseID(int appReleaseId, boolean unsubscribe, int tenantId, int offset, int limit)
+    List<SubscriptionEntity> getGroupsSubscriptionDetailsByAppReleaseID(int appReleaseId, boolean unsubscribe, int tenantId, int offset, int limit)
             throws ApplicationManagementDAOException;
 
     /**
@@ -355,7 +356,7 @@ public interface SubscriptionDAO {
      * @return {@link SubscriptionsDTO} which contains the details of subscriptions.
      * @throws ApplicationManagementDAOException if connection establishment or SQL execution fails.
      */
-    List<SubscriptionsDTO>  getRoleSubscriptionsByAppReleaseID(int appReleaseId, boolean unsubscribe, int tenantId, int offset, int limit)
+    List<SubscriptionEntity>  getRoleSubscriptionsByAppReleaseID(int appReleaseId, boolean unsubscribe, int tenantId, int offset, int limit)
             throws ApplicationManagementDAOException;
 
     /**
@@ -399,7 +400,8 @@ public interface SubscriptionDAO {
      */
     List<DeviceSubscriptionDTO> getSubscriptionDetailsByDeviceIds(int appReleaseId, boolean unsubscribe, int tenantId,
                                                                   List<Integer> deviceIds, String actionStatus, String actionType,
-                                                                  String actionTriggeredBy, String tabActionStatus) throws ApplicationManagementDAOException;
+                                                                  String actionTriggeredBy, String tabActionStatus,
+                                                                  int limit, int offset) throws ApplicationManagementDAOException;
 
     /**
      * This method is used to get the details of device subscriptions related to a UUID.

components/application-mgt/io.entgra.device.mgt.core.application.mgt.core/src/main/java/io/entgra/device/mgt/core/application/mgt/core/dao/impl/subscription/GenericSubscriptionDAOImpl.java

@@ -19,6 +19,7 @@ package io.entgra.device.mgt.core.application.mgt.core.dao.impl.subscription;
 
 import io.entgra.device.mgt.core.application.mgt.common.dto.GroupSubscriptionDTO;
 import io.entgra.device.mgt.core.application.mgt.common.dto.DeviceOperationDTO;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionEntity;
 import io.entgra.device.mgt.core.application.mgt.common.dto.SubscriptionsDTO;
 import io.entgra.device.mgt.core.application.mgt.core.dao.SubscriptionDAO;
 import io.entgra.device.mgt.core.application.mgt.core.dao.impl.AbstractDAOImpl;
@@ -1641,14 +1642,14 @@ public class GenericSubscriptionDAOImpl extends AbstractDAOImpl implements Subsc
     }
 
     @Override
-    public List<GroupSubscriptionDTO> getGroupsSubscriptionDetailsByAppReleaseID(int appReleaseId, boolean unsubscribe, int tenantId, int offset, int limit)
+    public List<SubscriptionEntity> getGroupsSubscriptionDetailsByAppReleaseID(int appReleaseId, boolean unsubscribe, int tenantId, int offset, int limit)
             throws ApplicationManagementDAOException {
         if (log.isDebugEnabled()) {
             log.debug("Request received in DAO Layer to get groups related to the given AppReleaseID.");
         }
         try {
             Connection conn = this.getDBConnection();
-            List<GroupSubscriptionDTO> groupDetails = new ArrayList<>();
+            List<SubscriptionEntity> subscriptionEntities = new ArrayList<>();
 
             String subscriptionStatusTime = unsubscribe ? "GS.UNSUBSCRIBED_TIMESTAMP" : "GS.SUBSCRIBED_TIMESTAMP";
             String sql = "SELECT GS.GROUP_NAME, GS.SUBSCRIBED_BY, GS.SUBSCRIBED_TIMESTAMP, GS.UNSUBSCRIBED, " +
@@ -1665,21 +1666,21 @@ public class GenericSubscriptionDAOImpl extends AbstractDAOImpl implements Subsc
                 ps.setInt(5, offset);
 
                 try (ResultSet rs = ps.executeQuery()) {
-                    GroupSubscriptionDTO groupDetail;
+                    SubscriptionEntity subscriptionEntity;
                     while (rs.next()) {
-                        groupDetail = new GroupSubscriptionDTO();
+                        subscriptionEntity = new SubscriptionEntity();
-                        groupDetail.setGroupName(rs.getString("GROUP_NAME"));
+                        subscriptionEntity.setIdentity(rs.getString("GROUP_NAME"));
-                        groupDetail.setSubscribedBy(rs.getString("SUBSCRIBED_BY"));
+                        subscriptionEntity.setSubscribedBy(rs.getString("SUBSCRIBED_BY"));
-                        groupDetail.setSubscribedTimestamp(rs.getTimestamp("SUBSCRIBED_TIMESTAMP"));
+                        subscriptionEntity.setSubscribedTimestamp(rs.getTimestamp("SUBSCRIBED_TIMESTAMP"));
-                        groupDetail.setUnsubscribed(rs.getBoolean("UNSUBSCRIBED"));
+                        subscriptionEntity.setUnsubscribed(rs.getBoolean("UNSUBSCRIBED"));
-                        groupDetail.setUnsubscribedBy(rs.getString("UNSUBSCRIBED_BY"));
+                        subscriptionEntity.setUnsubscribedBy(rs.getString("UNSUBSCRIBED_BY"));
-                        groupDetail.setUnsubscribedTimestamp(rs.getTimestamp("UNSUBSCRIBED_TIMESTAMP"));
+                        subscriptionEntity.setUnsubscribedTimestamp(rs.getTimestamp("UNSUBSCRIBED_TIMESTAMP"));
-                        groupDetail.setAppReleaseId(rs.getInt("AP_APP_RELEASE_ID"));
+                        subscriptionEntity.setApplicationReleaseId(rs.getInt("AP_APP_RELEASE_ID"));
 
-                        groupDetails.add(groupDetail);
+                        subscriptionEntities.add(subscriptionEntity);
                     }
                 }
-                return groupDetails;
+                return subscriptionEntities;
             }
         } catch (DBConnectionException e) {
             String msg = "Error occurred while obtaining the DB connection to get groups for the given UUID.";
@@ -1744,14 +1745,14 @@ public class GenericSubscriptionDAOImpl extends AbstractDAOImpl implements Subsc
     }
 
     @Override
-    public List<SubscriptionsDTO> getRoleSubscriptionsByAppReleaseID(int appReleaseId, boolean unsubscribe, int tenantId, int offset,
+    public List<SubscriptionEntity> getRoleSubscriptionsByAppReleaseID(int appReleaseId, boolean unsubscribe, int tenantId, int offset,
                                                                        int limit) throws ApplicationManagementDAOException {
         if (log.isDebugEnabled()) {
             log.debug("Request received in DAO Layer to get role subscriptions related to the given AppReleaseID.");
         }
         try {
             Connection conn = this.getDBConnection();
-            List<SubscriptionsDTO>  roleSubscriptions = new ArrayList<>();
+            List<SubscriptionEntity> subscriptionEntities = new ArrayList<>();
 
             String subscriptionStatusTime = unsubscribe ? "ARS.UNSUBSCRIBED_TIMESTAMP" : "ARS.SUBSCRIBED_TIMESTAMP";
             String sql = "SELECT ARS.ROLE_NAME, ARS.SUBSCRIBED_BY, ARS.SUBSCRIBED_TIMESTAMP, ARS.UNSUBSCRIBED, " +
@@ -1767,21 +1768,21 @@ public class GenericSubscriptionDAOImpl extends AbstractDAOImpl implements Subsc
                 ps.setInt(4, limit);
                 ps.setInt(5, offset);
                 try (ResultSet rs = ps.executeQuery()) {
-                    SubscriptionsDTO roleSubscription;
+                    SubscriptionEntity subscriptionEntity;
                     while (rs.next()) {
-                        roleSubscription = new SubscriptionsDTO();
+                        subscriptionEntity = new SubscriptionEntity();
-                        roleSubscription.setName(rs.getString("ROLE_NAME"));
+                        subscriptionEntity.setIdentity(rs.getString("ROLE_NAME"));
-                        roleSubscription.setSubscribedBy(rs.getString("SUBSCRIBED_BY"));
+                        subscriptionEntity.setSubscribedBy(rs.getString("SUBSCRIBED_BY"));
-                        roleSubscription.setSubscribedTimestamp(rs.getTimestamp("SUBSCRIBED_TIMESTAMP"));
+                        subscriptionEntity.setSubscribedTimestamp(rs.getTimestamp("SUBSCRIBED_TIMESTAMP"));
-                        roleSubscription.setUnsubscribed(rs.getBoolean("UNSUBSCRIBED"));
+                        subscriptionEntity.setUnsubscribed(rs.getBoolean("UNSUBSCRIBED"));
-                        roleSubscription.setUnsubscribedBy(rs.getString("UNSUBSCRIBED_BY"));
+                        subscriptionEntity.setUnsubscribedBy(rs.getString("UNSUBSCRIBED_BY"));
-                        roleSubscription.setUnsubscribedTimestamp(rs.getTimestamp("UNSUBSCRIBED_TIMESTAMP"));
+                        subscriptionEntity.setUnsubscribedTimestamp(rs.getTimestamp("UNSUBSCRIBED_TIMESTAMP"));
-                        roleSubscription.setAppReleaseId(rs.getInt("AP_APP_RELEASE_ID"));
+                        subscriptionEntity.setApplicationReleaseId(rs.getInt("AP_APP_RELEASE_ID"));
 
-                        roleSubscriptions.add(roleSubscription);
+                        subscriptionEntities.add(subscriptionEntity);
                     }
                 }
-                return roleSubscriptions;
+                return subscriptionEntities;
             }
         } catch (DBConnectionException e) {
             String msg = "Error occurred while obtaining the DB connection to get role subscriptions for the given UUID.";
@@ -1913,7 +1914,8 @@ public class GenericSubscriptionDAOImpl extends AbstractDAOImpl implements Subsc
     @Override
     public List<DeviceSubscriptionDTO> getSubscriptionDetailsByDeviceIds(int appReleaseId, boolean unsubscribe, int tenantId,
                                                                          List<Integer> deviceIds, String actionStatus, String actionType,
-                                                                         String actionTriggeredBy, String tabActionStatus) throws ApplicationManagementDAOException {
+                                                                         String actionTriggeredBy, String tabActionStatus,
+                                                                         int offset, int limit) throws ApplicationManagementDAOException {
         if (log.isDebugEnabled()) {
             log.debug("Getting device subscriptions for the application release id " + appReleaseId
                     + " and device ids " + deviceIds + " from the database");
@@ -1945,7 +1947,8 @@ public class GenericSubscriptionDAOImpl extends AbstractDAOImpl implements Subsc
                 sql.append(" AND DS.SUBSCRIBED_BY LIKE ? ");
             }
 
-            sql.append("ORDER BY ").append(subscriptionStatusTime).append(" DESC");
+            sql.append("ORDER BY ").append(subscriptionStatusTime).
+                    append(" DESC ").append("LIMIT ? OFFSET ?");
 
             try (PreparedStatement ps = conn.prepareStatement(sql.toString())) {
                 int paramIdx = 1;
@@ -1966,6 +1969,9 @@ public class GenericSubscriptionDAOImpl extends AbstractDAOImpl implements Subsc
                     ps.setString(paramIdx++, "%" + actionTriggeredBy + "%");
                 }
 
+                ps.setInt(paramIdx++, limit);
+                ps.setInt(paramIdx++, offset);
+
                 try (ResultSet rs = ps.executeQuery()) {
                     if (log.isDebugEnabled()) {
                         log.debug("Successfully retrieved device subscriptions for application release id "
@@ -2002,6 +2008,98 @@ public class GenericSubscriptionDAOImpl extends AbstractDAOImpl implements Subsc
 
     }
 
+//    @Override
+//    public List<DeviceSubscriptionDTO> getSubscriptionDetailsByDeviceIds(int appReleaseId, boolean unsubscribe, int tenantId,
+//                                                                         List<Integer> deviceIds, String actionStatus, String actionType,
+//                                                                         String actionTriggeredBy, String tabActionStatus) throws ApplicationManagementDAOException {
+//        if (log.isDebugEnabled()) {
+//            log.debug("Getting device subscriptions for the application release id " + appReleaseId
+//                    + " and device ids " + deviceIds + " from the database");
+//        }
+//        try {
+//            Connection conn = this.getDBConnection();
+//            String subscriptionStatusTime = unsubscribe ? "DS.UNSUBSCRIBED_TIMESTAMP" : "DS.SUBSCRIBED_TIMESTAMP";
+//            StringBuilder sql = new StringBuilder("SELECT "
+//                    + "DS.ID AS ID, "
+//                    + "DS.SUBSCRIBED_BY AS SUBSCRIBED_BY, "
+//                    + "DS.SUBSCRIBED_TIMESTAMP AS SUBSCRIBED_AT, "
+//                    + "DS.UNSUBSCRIBED AS IS_UNSUBSCRIBED, "
+//                    + "DS.UNSUBSCRIBED_BY AS UNSUBSCRIBED_BY, "
+//                    + "DS.UNSUBSCRIBED_TIMESTAMP AS UNSUBSCRIBED_AT, "
+//                    + "DS.ACTION_TRIGGERED_FROM AS ACTION_TRIGGERED_FROM, "
+//                    + "DS.STATUS AS STATUS, "
+//                    + "DS.DM_DEVICE_ID AS DEVICE_ID "
+//                    + "FROM AP_DEVICE_SUBSCRIPTION DS "
+//                    + "WHERE DS.AP_APP_RELEASE_ID = ? AND DS.UNSUBSCRIBED = ? AND DS.TENANT_ID = ? AND DS.DM_DEVICE_ID IN (" +
+//                    deviceIds.stream().map(id -> "?").collect(Collectors.joining(",")) + ") ");
+//
+//            if (actionStatus != null && !actionStatus.isEmpty()) {
+//                sql.append(" AND DS.STATUS = ? ");
+//            }
+//            if (actionType != null && !actionType.isEmpty()) {
+//                sql.append(" AND DS.ACTION_TRIGGERED_FROM = ? ");
+//            }
+//            if (actionTriggeredBy != null && !actionTriggeredBy.isEmpty()) {
+//                sql.append(" AND DS.SUBSCRIBED_BY LIKE ? ");
+//            }
+//
+//            sql.append("ORDER BY ").append(subscriptionStatusTime).append(" DESC");
+//
+//            try (PreparedStatement ps = conn.prepareStatement(sql.toString())) {
+//                int paramIdx = 1;
+//                ps.setInt(paramIdx++, appReleaseId);
+//                ps.setBoolean(paramIdx++, unsubscribe);
+//                ps.setInt(paramIdx++, tenantId);
+//                for (int i = 0; i < deviceIds.size(); i++) {
+//                    ps.setInt(paramIdx++, deviceIds.get(i));
+//                }
+//
+//                if (actionStatus != null && !actionStatus.isEmpty()) {
+//                    ps.setString(paramIdx++, actionStatus);
+//                }
+//                if (actionType != null && !actionType.isEmpty()) {
+//                    ps.setString(paramIdx++, actionType);
+//                }
+//                if (actionTriggeredBy != null && !actionTriggeredBy.isEmpty()) {
+//                    ps.setString(paramIdx++, "%" + actionTriggeredBy + "%");
+//                }
+//
+//                try (ResultSet rs = ps.executeQuery()) {
+//                    if (log.isDebugEnabled()) {
+//                        log.debug("Successfully retrieved device subscriptions for application release id "
+//                                + appReleaseId + " and device ids " + deviceIds);
+//                    }
+//                    List<DeviceSubscriptionDTO> subscriptions = new ArrayList<>();
+//                    while (rs.next()) {
+//                        DeviceSubscriptionDTO subscription = new DeviceSubscriptionDTO();
+//                        subscription.setId(rs.getInt("ID"));
+//                        subscription.setSubscribedBy(rs.getString("SUBSCRIBED_BY"));
+//                        subscription.setSubscribedTimestamp(rs.getTimestamp("SUBSCRIBED_AT"));
+//                        subscription.setUnsubscribed(rs.getBoolean("IS_UNSUBSCRIBED"));
+//                        subscription.setUnsubscribedBy(rs.getString("UNSUBSCRIBED_BY"));
+//                        subscription.setUnsubscribedTimestamp(rs.getTimestamp("UNSUBSCRIBED_AT"));
+//                        subscription.setActionTriggeredFrom(rs.getString("ACTION_TRIGGERED_FROM"));
+//                        subscription.setStatus(rs.getString("STATUS"));
+//                        subscription.setDeviceId(rs.getInt("DEVICE_ID"));
+//                        subscriptions.add(subscription);
+//                    }
+//                    return subscriptions;
+//                }
+//            } catch (SQLException e) {
+//                String msg = "Error occurred while running SQL to get device subscription data for application ID: " + appReleaseId
+//                        + " and device ids: " + deviceIds + ".";
+//                log.error(msg, e);
+//                throw new ApplicationManagementDAOException(msg, e);
+//            }
+//        } catch (DBConnectionException e) {
+//            String msg = "Error occurred while obtaining the DB connection for getting device subscriptions for "
+//                    + "application Id: " + appReleaseId + " and device ids: " + deviceIds + ".";
+//            log.error(msg, e);
+//            throw new ApplicationManagementDAOException(msg, e);
+//        }
+//
+//    }
+
     @Override
     public List<DeviceSubscriptionDTO> getAllSubscriptionsDetails(int appReleaseId, boolean unsubscribe, int tenantId,
                                                                   String actionStatus, String actionType, String actionTriggeredBy,

components/application-mgt/io.entgra.device.mgt.core.application.mgt.core/src/main/java/io/entgra/device/mgt/core/application/mgt/core/util/SubscriptionManagementUtil.java

@@ -0,0 +1,29 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.core.util;
+
+public class SubscriptionManagementUtil {
+    public static final class DeviceSubscriptionStatus {
+        public static final String COMPLETED = "COMPLETED";
+        public static final String ERROR ="ERROR";
+        public static final String NEW = "NEW";
+        public static final String SUBSCRIBED = "SUBSCRIBED";
+    }
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.core/src/main/java/io/entgra/device/mgt/core/application/mgt/core/util/subscription/mgt/SubscriptionManagementHelperUtil.java

@@ -0,0 +1,79 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt;
+
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscription;
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscriptionData;
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscriptionFilterCriteria;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionData;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionInfo;
+import io.entgra.device.mgt.core.application.mgt.common.dto.DeviceSubscriptionDTO;
+import io.entgra.device.mgt.core.application.mgt.core.util.HelperUtil;
+import io.entgra.device.mgt.core.device.mgt.common.Device;
+import io.entgra.device.mgt.core.device.mgt.common.PaginationRequest;
+import io.entgra.device.mgt.core.device.mgt.common.exceptions.DeviceManagementException;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class SubscriptionManagementHelperUtil {
+    public static List<DeviceSubscription> getDeviceSubscriptionData(List<DeviceSubscriptionDTO> deviceSubscriptionDTOS,
+                                                                     DeviceSubscriptionFilterCriteria deviceSubscriptionFilterCriteria) throws DeviceManagementException {
+        List<Integer> deviceIds = deviceSubscriptionDTOS.stream().map(DeviceSubscriptionDTO::getDeviceId).collect(Collectors.toList());
+        PaginationRequest paginationRequest = new PaginationRequest(0, -1);
+        paginationRequest.setDeviceName(deviceSubscriptionFilterCriteria.getName());
+        paginationRequest.setDeviceStatus(deviceSubscriptionFilterCriteria.getDeviceStatus());
+        paginationRequest.setOwner(deviceSubscriptionFilterCriteria.getOwner());
+        List<Device> devices = HelperUtil.getDeviceManagementProviderService().getDevicesByDeviceIds(paginationRequest, deviceIds);
+        return populateDeviceData(deviceSubscriptionDTOS, devices);
+    }
+
+    private static List<DeviceSubscription> populateDeviceData(List<DeviceSubscriptionDTO> deviceSubscriptionDTOS, List<Device> devices) {
+        List<DeviceSubscription> deviceSubscriptions = new ArrayList<>();
+        for (Device device : devices) {
+            int idx = deviceSubscriptionDTOS.indexOf(new DeviceSubscriptionDTO(device.getId()));
+            if (idx >= 0) {
+                DeviceSubscriptionDTO deviceSubscriptionDTO = deviceSubscriptionDTOS.get(idx);
+                DeviceSubscription deviceSubscription = new DeviceSubscription();
+                deviceSubscription.setDeviceIdentifier(device.getDeviceIdentifier());
+                deviceSubscription.setDeviceOwner(device.getEnrolmentInfo().getOwner());
+                deviceSubscription.setDeviceType(device.getType());
+                SubscriptionData subscriptionData = new SubscriptionData();
+                subscriptionData.setTriggeredBy(deviceSubscriptionDTO.getActionTriggeredFrom());
+                subscriptionData.setTriggeredAt(deviceSubscriptionDTO.getSubscribedTimestamp());
+                subscriptionData.setSubscriptionType(deviceSubscriptionDTO.getStatus());
+                deviceSubscription.setSubscriptionData(subscriptionData);
+                deviceSubscriptions.add(deviceSubscription);
+            }
+        }
+        return deviceSubscriptions;
+    }
+
+    public static String getDeviceSubscriptionStatus(SubscriptionInfo subscriptionInfo) {
+        return getDeviceSubscriptionStatus(subscriptionInfo.getDeviceSubscriptionFilterCriteria().
+                        getFilteringDeviceSubscriptionStatus(), subscriptionInfo.getDeviceSubscriptionStatus());
+    }
+
+    public static String getDeviceSubscriptionStatus(String deviceSubscriptionStatusFilter, String deviceSubscriptionStatus) {
+        return (deviceSubscriptionStatusFilter != null && !deviceSubscriptionStatusFilter.isEmpty()) ?
+                deviceSubscriptionStatusFilter : deviceSubscriptionStatus;
+    }
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.core/src/main/java/io/entgra/device/mgt/core/application/mgt/core/util/subscription/mgt/SubscriptionManagementServiceProvider.java

@@ -0,0 +1,49 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt;
+
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionInfo;
+import io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.impl.GroupBasedSubscriptionManagementHelperServiceImpl;
+import io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.impl.RoleBasedSubscriptionManagementHelperServiceImpl;
+import io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.service.SubscriptionManagementHelperService;
+
+import java.util.Objects;
+
+public class SubscriptionManagementServiceProvider {
+    private SubscriptionManagementServiceProvider() {}
+
+    private static class SubscriptionManagementProviderServiceHolder {
+        private static final SubscriptionManagementServiceProvider INSTANCE = new SubscriptionManagementServiceProvider();
+    }
+
+    public static SubscriptionManagementServiceProvider getInstance() {
+        return SubscriptionManagementProviderServiceHolder.INSTANCE;
+    }
+
+    public SubscriptionManagementHelperService getSubscriptionManagementHelperService(SubscriptionInfo subscriptionInfo) {
+        return getSubscriptionManagementHelperService(subscriptionInfo.getSubscriptionType());
+    }
+
+    private SubscriptionManagementHelperService getSubscriptionManagementHelperService(String subscriptionType) {
+        if (Objects.equals(subscriptionType, "role")) return RoleBasedSubscriptionManagementHelperServiceImpl.getInstance();
+        if (Objects.equals(subscriptionType, "group")) return GroupBasedSubscriptionManagementHelperServiceImpl.getInstance();
+        throw new UnsupportedOperationException("Subscription type: " + subscriptionType + " not supports");
+    }
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.core/src/main/java/io/entgra/device/mgt/core/application/mgt/core/util/subscription/mgt/bean/DeviceSubscriptionStatus.java

@@ -0,0 +1,24 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.bean;
+
+public enum DeviceSubscriptionStatus {
+    COMPLETED, ERROR, NEW, SUBSCRIBED
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.core/src/main/java/io/entgra/device/mgt/core/application/mgt/core/util/subscription/mgt/bean/RoleBasedSubscriptionInfo.java

@@ -0,0 +1,61 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.bean;
+
+public class RoleBasedSubscriptionInfo {
+
+    private String applicationUUID;
+    private String roleName;
+    private String subscriptionStatus;
+    public static String TRIGGERED_FROM_VALUE = "role";
+    private DeviceSubscriptionStatus deviceSubscriptionStatus;
+
+    public String getApplicationUUID() {
+        return applicationUUID;
+    }
+
+    public void setApplicationUUID(String applicationUUID) {
+        this.applicationUUID = applicationUUID;
+    }
+
+    public String getRoleName() {
+        return roleName;
+    }
+
+    public void setRoleName(String roleName) {
+        this.roleName = roleName;
+    }
+
+    public String getSubscriptionStatus() {
+        return subscriptionStatus;
+    }
+
+    public void setSubscriptionStatus(String subscriptionStatus) {
+        this.subscriptionStatus = subscriptionStatus;
+    }
+
+    public DeviceSubscriptionStatus getDeviceSubscriptionStatus() {
+        return deviceSubscriptionStatus;
+    }
+
+    public void setDeviceSubscriptionStatus(DeviceSubscriptionStatus deviceSubscriptionStatus) {
+        this.deviceSubscriptionStatus = deviceSubscriptionStatus;
+    }
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.core/src/main/java/io/entgra/device/mgt/core/application/mgt/core/util/subscription/mgt/impl/DeviceBasedSubscriptionManagementHelperServiceImpl.java

@@ -0,0 +1,48 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.impl;
+
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscription;
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscriptionData;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionEntity;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionInfo;
+import io.entgra.device.mgt.core.application.mgt.common.dto.DeviceSubscriptionDTO;
+import io.entgra.device.mgt.core.application.mgt.common.dto.SubscriptionsDTO;
+import io.entgra.device.mgt.core.application.mgt.common.exception.ApplicationManagementException;
+import io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.service.SubscriptionManagementHelperService;
+
+import java.util.List;
+
+public class DeviceBasedSubscriptionManagementHelperServiceImpl implements SubscriptionManagementHelperService {
+    @Override
+    public List<DeviceSubscription> getStatusBaseSubscriptions(SubscriptionInfo subscriptionInfo, int limit, int offset) throws ApplicationManagementException {
+        return null;
+    }
+
+    @Override
+    public List<SubscriptionEntity> getSubscriptions(SubscriptionInfo subscriptionInfo, int limit, int offset) throws ApplicationManagementException {
+        return null;
+    }
+
+    @Override
+    public void getSubscriptionStatistics() throws ApplicationManagementException {
+
+    }
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.core/src/main/java/io/entgra/device/mgt/core/application/mgt/core/util/subscription/mgt/impl/GroupBasedSubscriptionManagementHelperServiceImpl.java

@@ -0,0 +1,161 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.impl;
+
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscription;
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscriptionData;
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscriptionFilterCriteria;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionEntity;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionInfo;
+import io.entgra.device.mgt.core.application.mgt.common.dto.ApplicationDTO;
+import io.entgra.device.mgt.core.application.mgt.common.dto.ApplicationReleaseDTO;
+import io.entgra.device.mgt.core.application.mgt.common.dto.DeviceSubscriptionDTO;
+import io.entgra.device.mgt.core.application.mgt.common.exception.ApplicationManagementException;
+import io.entgra.device.mgt.core.application.mgt.common.exception.DBConnectionException;
+import io.entgra.device.mgt.core.application.mgt.core.exception.ApplicationManagementDAOException;
+import io.entgra.device.mgt.core.application.mgt.core.exception.NotFoundException;
+import io.entgra.device.mgt.core.application.mgt.core.util.ConnectionManagerUtil;
+import io.entgra.device.mgt.core.application.mgt.core.util.HelperUtil;
+import io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.SubscriptionManagementHelperUtil;
+import io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.service.SubscriptionManagementHelperService;
+import io.entgra.device.mgt.core.device.mgt.common.exceptions.DeviceManagementException;
+import io.entgra.device.mgt.core.device.mgt.common.group.mgt.GroupManagementException;
+import io.entgra.device.mgt.core.device.mgt.core.dto.GroupDetailsDTO;
+import io.entgra.device.mgt.core.device.mgt.core.service.GroupManagementProviderService;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.wso2.carbon.context.PrivilegedCarbonContext;
+
+import java.util.List;
+import java.util.Objects;
+
+public class GroupBasedSubscriptionManagementHelperServiceImpl implements SubscriptionManagementHelperService {
+    private static final Log log = LogFactory.getLog(GroupBasedSubscriptionManagementHelperServiceImpl.class);
+    private GroupBasedSubscriptionManagementHelperServiceImpl() {}
+    private static class GroupBasedSubscriptionManagementHelperServiceImplHolder {
+        private static final GroupBasedSubscriptionManagementHelperServiceImpl INSTANCE
+                = new GroupBasedSubscriptionManagementHelperServiceImpl();
+    }
+
+    public static GroupBasedSubscriptionManagementHelperServiceImpl getInstance() {
+        return GroupBasedSubscriptionManagementHelperServiceImplHolder.INSTANCE;
+    }
+
+    @Override
+    public List<DeviceSubscription> getStatusBaseSubscriptions(SubscriptionInfo subscriptionInfo, int limit, int offset)
+            throws ApplicationManagementException {
+
+        final boolean isUnsubscribe = Objects.equals("unsubscribe", subscriptionInfo.getSubscriptionStatus());
+        List<DeviceSubscriptionDTO> deviceSubscriptionDTOS;
+        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
+        // todo: check and refactor
+        try {
+            ConnectionManagerUtil.openDBConnection();
+            ApplicationReleaseDTO applicationReleaseDTO = applicationReleaseDAO.
+                    getReleaseByUUID(subscriptionInfo.getApplicationUUID(), tenantId);
+
+            if (applicationReleaseDTO == null) {
+                String msg = "Couldn't find an application release for application release UUID: " +
+                        subscriptionInfo.getApplicationUUID();
+                log.error(msg);
+                throw new NotFoundException(msg);
+            }
+
+            ApplicationDTO applicationDTO = this.applicationDAO.getAppWithRelatedRelease(subscriptionInfo.getApplicationUUID(), tenantId);
+            if (applicationDTO == null) {
+                String msg = "Application not found for the release UUID: " + subscriptionInfo.getApplicationUUID();
+                log.error(msg);
+                throw new NotFoundException(msg);
+            }
+
+            String deviceSubscriptionStatus = SubscriptionManagementHelperUtil.getDeviceSubscriptionStatus(subscriptionInfo);
+            DeviceSubscriptionFilterCriteria deviceSubscriptionFilterCriteria = subscriptionInfo.getDeviceSubscriptionFilterCriteria();
+
+            GroupManagementProviderService groupManagementProviderService = HelperUtil.getGroupManagementProviderService();
+            GroupDetailsDTO groupDetailsDTO = groupManagementProviderService.getGroupDetailsWithDevices(subscriptionInfo.getIdentifier(),
+                    applicationDTO.getDeviceTypeId(), deviceSubscriptionFilterCriteria.getOwner(), deviceSubscriptionFilterCriteria.getName(),
+                    deviceSubscriptionFilterCriteria.getDeviceStatus(), offset, limit);
+
+            List<Integer> deviceIdsOwnByGroup = groupDetailsDTO.getDeviceIds();
+
+            if (Objects.equals("NEW", deviceSubscriptionStatus)) {
+
+                deviceSubscriptionDTOS = subscriptionDAO.getSubscriptionDetailsByDeviceIds(applicationReleaseDTO.getId(),
+                        isUnsubscribe, tenantId, deviceIdsOwnByGroup, null,
+                        subscriptionInfo.getSubscriptionType(), deviceSubscriptionFilterCriteria.getTriggeredBy(),
+                        null, limit, offset);
+                for (DeviceSubscriptionDTO deviceSubscriptionDTO: deviceSubscriptionDTOS) {
+                    deviceIdsOwnByGroup.remove(deviceSubscriptionDTO.getDeviceId());
+                }
+            }
+
+            deviceSubscriptionDTOS = subscriptionDAO.getSubscriptionDetailsByDeviceIds(applicationReleaseDTO.getId(),
+                    isUnsubscribe, tenantId, deviceIdsOwnByGroup, deviceSubscriptionStatus, subscriptionInfo.getSubscriptionType(),
+                    deviceSubscriptionFilterCriteria.getTriggeredBy(), deviceSubscriptionStatus, limit, offset);
+        return SubscriptionManagementHelperUtil.getDeviceSubscriptionData(deviceSubscriptionDTOS,
+                subscriptionInfo.getDeviceSubscriptionFilterCriteria());
+
+        } catch (GroupManagementException e) {
+            String msg = "Error encountered while retrieving group details for group: " + subscriptionInfo.getIdentifier();
+            log.error(msg, e);
+            throw new ApplicationManagementException(msg, e);
+        } catch (ApplicationManagementDAOException | DBConnectionException e) {
+            String msg = "Error encountered while connecting to the database";
+            log.error(msg, e);
+            throw new ApplicationManagementException(msg, e);
+        } catch (DeviceManagementException e) {
+            throw new RuntimeException(e);
+        } finally {
+            ConnectionManagerUtil.closeDBConnection();
+        }
+
+    }
+
+    @Override
+    public List<SubscriptionEntity> getSubscriptions(SubscriptionInfo subscriptionInfo, int limit, int offset)
+            throws ApplicationManagementException {
+        final boolean isUnsubscribe = Objects.equals("unsubscribe", subscriptionInfo.getSubscriptionStatus());
+        final int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
+        try {
+            ConnectionManagerUtil.openDBConnection();
+            ApplicationReleaseDTO applicationReleaseDTO = applicationReleaseDAO.
+                    getReleaseByUUID(subscriptionInfo.getApplicationUUID(), tenantId);
+            if (applicationReleaseDTO == null) {
+                String msg = "Couldn't find an application release for application release UUID: " +
+                        subscriptionInfo.getApplicationUUID();
+                log.error(msg);
+                throw new NotFoundException(msg);
+            }
+            return subscriptionDAO.
+                    getGroupsSubscriptionDetailsByAppReleaseID(applicationReleaseDTO.getId(), isUnsubscribe, tenantId, offset, limit);
+        } catch (DBConnectionException | ApplicationManagementDAOException e) {
+            String msg = "Error encountered while connecting to the database";
+            log.error(msg, e);
+            throw new ApplicationManagementException(msg, e);
+        } finally {
+            ConnectionManagerUtil.closeDBConnection();
+        }
+    }
+
+    @Override
+    public void getSubscriptionStatistics() throws ApplicationManagementException {
+
+    }
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.core/src/main/java/io/entgra/device/mgt/core/application/mgt/core/util/subscription/mgt/impl/RoleBasedSubscriptionManagementHelperServiceImpl.java

@@ -0,0 +1,171 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.impl;
+
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscription;
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscriptionData;
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscriptionFilterCriteria;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionEntity;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionInfo;
+import io.entgra.device.mgt.core.application.mgt.common.dto.ApplicationReleaseDTO;
+import io.entgra.device.mgt.core.application.mgt.common.dto.DeviceSubscriptionDTO;
+import io.entgra.device.mgt.core.application.mgt.common.exception.ApplicationManagementException;
+import io.entgra.device.mgt.core.application.mgt.common.exception.DBConnectionException;
+import io.entgra.device.mgt.core.application.mgt.core.exception.ApplicationManagementDAOException;
+import io.entgra.device.mgt.core.application.mgt.core.exception.NotFoundException;
+import io.entgra.device.mgt.core.application.mgt.core.internal.DataHolder;
+import io.entgra.device.mgt.core.application.mgt.core.util.ConnectionManagerUtil;
+import io.entgra.device.mgt.core.application.mgt.core.util.HelperUtil;
+import io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.SubscriptionManagementHelperUtil;
+import io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.service.SubscriptionManagementHelperService;
+import io.entgra.device.mgt.core.device.mgt.common.Device;
+import io.entgra.device.mgt.core.device.mgt.common.PaginationRequest;
+import io.entgra.device.mgt.core.device.mgt.common.PaginationResult;
+import io.entgra.device.mgt.core.device.mgt.common.exceptions.DeviceManagementException;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.wso2.carbon.context.PrivilegedCarbonContext;
+import org.wso2.carbon.user.api.UserStoreException;
+import org.wso2.carbon.user.api.UserStoreManager;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class RoleBasedSubscriptionManagementHelperServiceImpl implements SubscriptionManagementHelperService {
+    private static final Log log = LogFactory.getLog(RoleBasedSubscriptionManagementHelperServiceImpl.class);
+    private RoleBasedSubscriptionManagementHelperServiceImpl() {}
+    private static class RoleBasedSubscriptionManagementHelperServiceImplHolder {
+        private static final RoleBasedSubscriptionManagementHelperServiceImpl INSTANCE
+                = new RoleBasedSubscriptionManagementHelperServiceImpl();
+    }
+
+    public static RoleBasedSubscriptionManagementHelperServiceImpl getInstance() {
+        return RoleBasedSubscriptionManagementHelperServiceImplHolder.INSTANCE;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public List<DeviceSubscription> getStatusBaseSubscriptions(SubscriptionInfo subscriptionInfo, int limit, int offset)
+            throws ApplicationManagementException {
+        final boolean isUnsubscribe = Objects.equals("unsubscribe", subscriptionInfo.getSubscriptionStatus());
+        List<DeviceSubscriptionDTO> deviceSubscriptionDTOS;
+        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
+
+        try {
+            ConnectionManagerUtil.openDBConnection();
+            UserStoreManager userStoreManager = DataHolder.getInstance().getRealmService().
+                    getTenantUserRealm(tenantId).getUserStoreManager();
+            String[] usersWithRole =
+                    userStoreManager.getUserListOfRole(subscriptionInfo.getIdentifier());
+            List<Device> deviceListOwnByRole = new ArrayList<>();
+            for (String user : usersWithRole) {
+                PaginationRequest paginationRequest = new PaginationRequest(offset, limit);
+                paginationRequest.setOwner(user);
+                paginationRequest.setStatusList(Arrays.asList("ACTIVE", "INACTIVE", "UNREACHABLE"));
+                PaginationResult ownDeviceIds = HelperUtil.getDeviceManagementProviderService().
+                        getAllDevicesIdList(paginationRequest);
+                if (ownDeviceIds.getData() != null) {
+                    deviceListOwnByRole.addAll((List<Device>)ownDeviceIds.getData());
+                }
+            }
+
+            List<Integer> deviceIdsOwnByRole = deviceListOwnByRole.stream().map(Device::getId).collect(Collectors.toList());
+
+            ApplicationReleaseDTO applicationReleaseDTO = applicationReleaseDAO.
+                    getReleaseByUUID(subscriptionInfo.getApplicationUUID(), tenantId);
+            if (applicationReleaseDTO == null) {
+                String msg = "Couldn't find an application release for application release UUID: " +
+                        subscriptionInfo.getApplicationUUID();
+                log.error(msg);
+                throw new NotFoundException(msg);
+            }
+
+            String deviceSubscriptionStatus = SubscriptionManagementHelperUtil.getDeviceSubscriptionStatus(subscriptionInfo);
+            DeviceSubscriptionFilterCriteria deviceSubscriptionFilterCriteria = subscriptionInfo.getDeviceSubscriptionFilterCriteria();
+
+            deviceSubscriptionDTOS = subscriptionDAO.getSubscriptionDetailsByDeviceIds(applicationReleaseDTO.getId(),
+                    isUnsubscribe, tenantId, deviceIdsOwnByRole, null,
+                    subscriptionInfo.getSubscriptionType(), deviceSubscriptionFilterCriteria.getTriggeredBy(),
+                    null, limit, offset);
+
+            if (Objects.equals("NEW", deviceSubscriptionStatus)) {
+
+                List<Integer> deviceIdsOfSubscription = deviceSubscriptionDTOS.stream().
+                        map(DeviceSubscriptionDTO::getDeviceId).collect(Collectors.toList());
+
+                List<Integer> newDeviceIds = HelperUtil.getDeviceManagementProviderService().
+                        getDevicesNotInGivenIdList(deviceIdsOfSubscription, new PaginationRequest(offset, limit));
+                deviceSubscriptionDTOS = newDeviceIds.stream().map(DeviceSubscriptionDTO::new).collect(Collectors.toList());
+            }
+
+            return SubscriptionManagementHelperUtil.getDeviceSubscriptionData(deviceSubscriptionDTOS,
+                    subscriptionInfo.getDeviceSubscriptionFilterCriteria());
+
+        } catch (UserStoreException e) {
+            String msg = "Error encountered while getting the user management store for tenant id " + tenantId;
+            log.error(msg, e);
+            throw new ApplicationManagementException(msg, e);
+        } catch (DeviceManagementException e) {
+            String msg = "Error encountered while getting device details";
+            log.error(msg, e);
+            throw new ApplicationManagementException(msg, e);
+        } catch (ApplicationManagementDAOException | DBConnectionException e) {
+            String msg = "Error encountered while connecting to the database";
+            log.error(msg, e);
+            throw new ApplicationManagementException(msg, e);
+        } finally {
+            ConnectionManagerUtil.closeDBConnection();
+        }
+    }
+
+    @Override
+    public List<SubscriptionEntity> getSubscriptions(SubscriptionInfo subscriptionInfo, int limit, int offset)
+            throws ApplicationManagementException {
+        final boolean isUnsubscribe = Objects.equals("unsubscribe", subscriptionInfo.getSubscriptionStatus());
+        final int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
+        try {
+            ConnectionManagerUtil.openDBConnection();
+            ApplicationReleaseDTO applicationReleaseDTO = applicationReleaseDAO.
+                    getReleaseByUUID(subscriptionInfo.getApplicationUUID(), tenantId);
+            if (applicationReleaseDTO == null) {
+                String msg = "Couldn't find an application release for application release UUID: " +
+                        subscriptionInfo.getApplicationUUID();
+                log.error(msg);
+                throw new NotFoundException(msg);
+            }
+            return subscriptionDAO.
+                    getRoleSubscriptionsByAppReleaseID(applicationReleaseDTO.getId(), isUnsubscribe, tenantId, offset, limit);
+        } catch (DBConnectionException | ApplicationManagementDAOException e) {
+            String msg = "Error encountered while connecting to the database";
+            log.error(msg, e);
+            throw new ApplicationManagementException(msg, e);
+        } finally {
+            ConnectionManagerUtil.closeDBConnection();
+        }
+    }
+
+    @Override
+    public void getSubscriptionStatistics() throws ApplicationManagementException {
+
+    }
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.core/src/main/java/io/entgra/device/mgt/core/application/mgt/core/util/subscription/mgt/impl/UserBasedSubscriptionManagementHelperServiceImpl.java

@@ -0,0 +1,273 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.impl;
+
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscription;
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscriptionData;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionEntity;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionInfo;
+import io.entgra.device.mgt.core.application.mgt.common.dto.DeviceSubscriptionDTO;
+import io.entgra.device.mgt.core.application.mgt.common.dto.SubscriptionsDTO;
+import io.entgra.device.mgt.core.application.mgt.common.exception.ApplicationManagementException;
+import io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.service.SubscriptionManagementHelperService;
+
+import java.util.List;
+
+/*
+//    @Override
+//    public List<SubscriptionsDTO> getUserSubscriptionsByUUID(String uuid, String subscriptionStatus,
+//                                                             PaginationRequest request, int offset, int limit)
+//            throws ApplicationManagementException {
+//        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true);
+//        boolean unsubscribe = subscriptionStatus.equals("unsubscribed");
+//        String status;
+//
+//        try {
+//            ConnectionManagerUtil.openDBConnection();
+//
+//            ApplicationReleaseDTO applicationReleaseDTO = this.applicationReleaseDAO.getReleaseByUUID(uuid, tenantId);
+//            if (applicationReleaseDTO == null) {
+//                String msg = "Couldn't find an application release for application release UUID: " + uuid;
+//                log.error(msg);
+//                throw new NotFoundException(msg);
+//            }
+//            ApplicationDTO applicationDTO = this.applicationDAO.getAppWithRelatedRelease(uuid, tenantId);
+//            int appReleaseId = applicationReleaseDTO.getId();
+//            List<SubscriptionsDTO> userSubscriptionsWithDevices = new ArrayList<>();
+//
+//            List<SubscriptionsDTO> userSubscriptions =
+//                    subscriptionDAO.getUserSubscriptionsByAppReleaseID(appReleaseId, unsubscribe, tenantId, offset, limit);
+//            if (userSubscriptions == null) {
+//                throw new ApplicationManagementException("User details not found for appReleaseId: " + appReleaseId);
+//            }
+//
+//            DeviceManagementProviderService deviceManagementProviderService = HelperUtil.getDeviceManagementProviderService();
+//
+//            for (SubscriptionsDTO userSubscription : userSubscriptions) {
+//
+//                if (StringUtils.isNotBlank(request.getUserName()) && !request.getUserName().equals(userSubscription.getName())) {
+//                    continue;
+//                }
+//
+//                String userName = StringUtils.isNotBlank(request.getUserName()) ? request.getUserName() : userSubscription.getName();
+//
+//                // Retrieve owner details and device IDs for the user using the service layer
+//                OwnerWithDeviceDTO ownerDetailsWithDevices =
+//                        deviceManagementProviderService.getOwnersWithDeviceIds(userName, applicationDTO.getDeviceTypeId(),
+//                                request.getOwner(), request.getDeviceName(), request.getDeviceStatus());
+//
+//                SubscriptionsDTO userSubscriptionDTO = new SubscriptionsDTO();
+//                userSubscriptionDTO.setName(userSubscription.getName());
+//                userSubscriptionDTO.setSubscribedBy(userSubscription.getSubscribedBy());
+//                userSubscriptionDTO.setSubscribedTimestamp(userSubscription.getSubscribedTimestamp());
+//                userSubscriptionDTO.setUnsubscribed(userSubscription.getUnsubscribed());
+//                userSubscriptionDTO.setUnsubscribedBy(userSubscription.getUnsubscribedBy());
+//                userSubscriptionDTO.setUnsubscribedTimestamp(userSubscription.getUnsubscribedTimestamp());
+//                userSubscriptionDTO.setAppReleaseId(userSubscription.getAppReleaseId());
+//
+//                userSubscriptionDTO.setDeviceCount(ownerDetailsWithDevices.getDeviceCount());
+//
+//                // Fetch device subscriptions for each device ID associated with the user
+//                List<DeviceSubscriptionData> pendingDevices = new ArrayList<>();
+//                List<DeviceSubscriptionData> installedDevices = new ArrayList<>();
+//                List<DeviceSubscriptionData> errorDevices = new ArrayList<>();
+//                List<DeviceSubscriptionData> newDevices = new ArrayList<>();
+//                List<DeviceSubscriptionData> subscribedDevices = new ArrayList<>();
+//
+//                List<Integer> deviceIds = ownerDetailsWithDevices.getDeviceIds();
+//                Map<String, Integer> statusCounts = new HashMap<>();
+//                statusCounts.put("PENDING", 0);
+//                statusCounts.put("COMPLETED", 0);
+//                statusCounts.put("ERROR", 0);
+//                statusCounts.put("NEW", 0);
+//                statusCounts.put("SUBSCRIBED", 0);
+//
+//                List<DeviceSubscriptionDTO> subscribedDeviceSubscriptions = new ArrayList<>();
+//                if (unsubscribe) {
+//                    subscribedDeviceSubscriptions = subscriptionDAO.getSubscriptionDetailsByDeviceIds(
+//                            appReleaseId, !unsubscribe, tenantId, deviceIds, request.getActionStatus(), request.getActionType(),
+//                            request.getActionTriggeredBy(), request.getTabActionStatus());
+//                }
+//
+//                for (Integer deviceId : deviceIds) {
+//                    List<DeviceSubscriptionDTO> deviceSubscriptions = subscriptionDAO.getSubscriptionDetailsByDeviceIds(
+//                            userSubscription.getAppReleaseId(), unsubscribe, tenantId, deviceIds, request.getActionStatus(), request.getActionType(),
+//                            request.getActionTriggeredBy(), request.getTabActionStatus());
+//                    OwnerWithDeviceDTO ownerWithDeviceByDeviceId =
+//                            deviceManagementProviderService.getOwnerWithDeviceByDeviceId(deviceId, request.getOwner(), request.getDeviceName(),
+//                                    request.getDeviceStatus());
+//                    if (ownerWithDeviceByDeviceId == null) {
+//                        continue;
+//                    }
+//                    boolean isNewDevice = true;
+//                    for (DeviceSubscriptionDTO subscription : deviceSubscriptions) {
+//                        if (subscription.getDeviceId() == deviceId) {
+//                            DeviceSubscriptionData deviceDetail = new DeviceSubscriptionData();
+//                            deviceDetail.setDeviceId(subscription.getDeviceId());
+//                            deviceDetail.setSubId(subscription.getId());
+//                            deviceDetail.setDeviceOwner(ownerWithDeviceByDeviceId.getUserName());
+//                            deviceDetail.setDeviceStatus(ownerWithDeviceByDeviceId.getDeviceStatus());
+//                            deviceDetail.setDeviceName(ownerWithDeviceByDeviceId.getDeviceNames());
+//                            deviceDetail.setActionType(subscription.getActionTriggeredFrom());
+//                            deviceDetail.setStatus(subscription.getStatus());
+//                            deviceDetail.setActionType(subscription.getActionTriggeredFrom());
+//                            deviceDetail.setActionTriggeredBy(subscription.getSubscribedBy());
+//                            deviceDetail.setActionTriggeredTimestamp(subscription.getSubscribedTimestamp());
+//                            deviceDetail.setUnsubscribed(subscription.isUnsubscribed());
+//                            deviceDetail.setUnsubscribedBy(subscription.getUnsubscribedBy());
+//                            deviceDetail.setUnsubscribedTimestamp(subscription.getUnsubscribedTimestamp());
+//                            deviceDetail.setType(ownerWithDeviceByDeviceId.getDeviceTypes());
+//                            deviceDetail.setDeviceIdentifier(ownerWithDeviceByDeviceId.getDeviceIdentifiers());
+//
+//                            status = subscription.getStatus();
+//                            switch (status) {
+//                                case "COMPLETED":
+//                                    installedDevices.add(deviceDetail);
+//                                    statusCounts.put("COMPLETED", statusCounts.get("COMPLETED") + 1);
+//                                    break;
+//                                case "ERROR":
+//                                case "INVALID":
+//                                case "UNAUTHORIZED":
+//                                    errorDevices.add(deviceDetail);
+//                                    statusCounts.put("ERROR", statusCounts.get("ERROR") + 1);
+//                                    break;
+//                                case "IN_PROGRESS":
+//                                case "PENDING":
+//                                case "REPEATED":
+//                                    pendingDevices.add(deviceDetail);
+//                                    statusCounts.put("PENDING", statusCounts.get("PENDING") + 1);
+//                                    break;
+//                            }
+//                            isNewDevice = false;
+//                        }
+//                    }
+//                    if (isNewDevice) {
+//                        boolean isSubscribedDevice = false;
+//                        for (DeviceSubscriptionDTO subscribedDevice : subscribedDeviceSubscriptions) {
+//                            if (subscribedDevice.getDeviceId() == deviceId) {
+//                                DeviceSubscriptionData subscribedDeviceDetail = new DeviceSubscriptionData();
+//                                subscribedDeviceDetail.setDeviceId(subscribedDevice.getDeviceId());
+//                                subscribedDeviceDetail.setDeviceName(ownerWithDeviceByDeviceId.getDeviceNames());
+//                                subscribedDeviceDetail.setDeviceOwner(ownerWithDeviceByDeviceId.getUserName());
+//                                subscribedDeviceDetail.setDeviceStatus(ownerWithDeviceByDeviceId.getDeviceStatus());
+//                                subscribedDeviceDetail.setSubId(subscribedDevice.getId());
+//                                subscribedDeviceDetail.setActionTriggeredBy(subscribedDevice.getSubscribedBy());
+//                                subscribedDeviceDetail.setActionTriggeredTimestamp(subscribedDevice.getSubscribedTimestamp());
+//                                subscribedDeviceDetail.setActionType(subscribedDevice.getActionTriggeredFrom());
+//                                subscribedDeviceDetail.setStatus(subscribedDevice.getStatus());
+//                                subscribedDeviceDetail.setType(ownerWithDeviceByDeviceId.getDeviceTypes());
+//                                subscribedDeviceDetail.setDeviceIdentifier(ownerWithDeviceByDeviceId.getDeviceIdentifiers());
+//                                subscribedDevices.add(subscribedDeviceDetail);
+//                                statusCounts.put("SUBSCRIBED", statusCounts.get("SUBSCRIBED") + 1);
+//                                isSubscribedDevice = true;
+//                                break;
+//                            }
+//                        }
+//                        if (!isSubscribedDevice) {
+//                            DeviceSubscriptionData newDeviceDetail = new DeviceSubscriptionData();
+//                            newDeviceDetail.setDeviceId(deviceId);
+//                            newDeviceDetail.setDeviceOwner(ownerWithDeviceByDeviceId.getUserName());
+//                            newDeviceDetail.setDeviceStatus(ownerWithDeviceByDeviceId.getDeviceStatus());
+//                            newDeviceDetail.setDeviceName(ownerWithDeviceByDeviceId.getDeviceNames());
+//                            newDeviceDetail.setType(ownerWithDeviceByDeviceId.getDeviceTypes());
+//                            newDeviceDetail.setDeviceIdentifier(ownerWithDeviceByDeviceId.getDeviceIdentifiers());
+//                            newDevices.add(newDeviceDetail);
+//                            statusCounts.put("NEW", statusCounts.get("NEW") + 1);
+//                        }
+//                    }
+//                }
+//
+//                int totalDevices = deviceIds.size();
+//                Map<String, Double> statusPercentages = new HashMap<>();
+//                for (Map.Entry<String, Integer> entry : statusCounts.entrySet()) {
+//                    double percentage = ((double) entry.getValue() / totalDevices) * 100;
+//                    String formattedPercentage = String.format("%.2f", percentage);
+//                    statusPercentages.put(entry.getKey(), Double.valueOf(formattedPercentage));
+//                }
+//
+//                List<DeviceSubscriptionData> requestedDevices = new ArrayList<>();
+//                if (StringUtils.isNotBlank(request.getTabActionStatus())) {
+//                    switch (request.getTabActionStatus()) {
+//                        case "COMPLETED":
+//                            requestedDevices = installedDevices;
+//                            break;
+//                        case "PENDING":
+//                            requestedDevices = pendingDevices;
+//                            break;
+//                        case "ERROR":
+//                            requestedDevices = errorDevices;
+//                            break;
+//                        case "NEW":
+//                            requestedDevices = newDevices;
+//                            break;
+//                        case "SUBSCRIBED":
+//                            requestedDevices = subscribedDevices;
+//                            break;
+//                    }
+//                    userSubscriptionDTO.setDevices(new CategorizedSubscriptionResult(requestedDevices, request.getTabActionStatus()));
+//                } else {
+//                    CategorizedSubscriptionResult categorizedSubscriptionResult;
+//                    if (subscribedDevices.isEmpty()) {
+//                        categorizedSubscriptionResult =
+//                                new CategorizedSubscriptionResult(installedDevices, pendingDevices, errorDevices, newDevices);
+//                    } else {
+//                        categorizedSubscriptionResult =
+//                                new CategorizedSubscriptionResult(installedDevices, pendingDevices, errorDevices, newDevices,
+//                                        subscribedDevices);
+//                    }
+//                    userSubscriptionDTO.setDevices(categorizedSubscriptionResult);
+//                    userSubscriptionDTO.setStatusPercentages(statusPercentages);
+//
+//                }
+//                userSubscriptionsWithDevices.add(userSubscriptionDTO);
+//            }
+//            return userSubscriptionsWithDevices;
+//        } catch (ApplicationManagementDAOException e) {
+//            String msg = "Error occurred while getting user subscriptions for the application release UUID: " + uuid;
+//            log.error(msg, e);
+//            throw new ApplicationManagementException(msg, e);
+//        } catch (DBConnectionException e) {
+//            String msg = "DB Connection error occurred while getting user subscriptions for UUID: " + uuid;
+//            log.error(msg, e);
+//            throw new ApplicationManagementException(msg, e);
+//        } catch (DeviceManagementDAOException e) {
+//            throw new RuntimeException(e);
+//        } finally {
+//            ConnectionManagerUtil.closeDBConnection();
+//        }
+//    }
+ */
+public class UserBasedSubscriptionManagementHelperServiceImpl implements SubscriptionManagementHelperService {
+    @Override
+    public List<DeviceSubscription> getStatusBaseSubscriptions(SubscriptionInfo subscriptionInfo, int limit, int offset)
+            throws ApplicationManagementException {
+        return null;
+    }
+
+    @Override
+    public List<SubscriptionEntity> getSubscriptions(SubscriptionInfo subscriptionInfo, int limit, int offset) throws ApplicationManagementException {
+        return null;
+    }
+
+    @Override
+    public void getSubscriptionStatistics() throws ApplicationManagementException {
+
+    }
+}

components/application-mgt/io.entgra.device.mgt.core.application.mgt.core/src/main/java/io/entgra/device/mgt/core/application/mgt/core/util/subscription/mgt/service/SubscriptionManagementHelperService.java

@@ -0,0 +1,45 @@
+/*
+ *  Copyright (c) 2018 - 2024, 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 io.entgra.device.mgt.core.application.mgt.core.util.subscription.mgt.service;
+
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscription;
+import io.entgra.device.mgt.core.application.mgt.common.DeviceSubscriptionData;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionEntity;
+import io.entgra.device.mgt.core.application.mgt.common.SubscriptionInfo;
+import io.entgra.device.mgt.core.application.mgt.common.dto.DeviceSubscriptionDTO;
+import io.entgra.device.mgt.core.application.mgt.common.dto.SubscriptionsDTO;
+import io.entgra.device.mgt.core.application.mgt.common.exception.ApplicationManagementException;
+import io.entgra.device.mgt.core.application.mgt.core.dao.ApplicationDAO;
+import io.entgra.device.mgt.core.application.mgt.core.dao.ApplicationReleaseDAO;
+import io.entgra.device.mgt.core.application.mgt.core.dao.SubscriptionDAO;
+import io.entgra.device.mgt.core.application.mgt.core.dao.common.ApplicationManagementDAOFactory;
+
+import java.util.List;
+
+public interface SubscriptionManagementHelperService {
+    SubscriptionDAO subscriptionDAO = ApplicationManagementDAOFactory.getSubscriptionDAO();
+    ApplicationDAO applicationDAO = ApplicationManagementDAOFactory.getApplicationDAO();
+    ApplicationReleaseDAO applicationReleaseDAO = ApplicationManagementDAOFactory.getApplicationReleaseDAO();
+    List<DeviceSubscription> getStatusBaseSubscriptions(SubscriptionInfo subscriptionInfo, int limit, int offset)
+            throws ApplicationManagementException;
+    List<SubscriptionEntity> getSubscriptions(SubscriptionInfo subscriptionInfo, int limit, int offset)
+            throws ApplicationManagementException;
+    void getSubscriptionStatistics() throws ApplicationManagementException;
+}

components/device-mgt/io.entgra.device.mgt.core.device.mgt.common/src/main/java/io/entgra/device/mgt/core/device/mgt/common/Device.java

@@ -97,6 +97,10 @@ public class Device implements Serializable {
     public Device() {
     }
 
+    public Device(int id) {
+        this.id = id;
+    }
+
     public Device(String name, String type, String description, String deviceId, EnrolmentInfo enrolmentInfo,
                   List<Feature> features, List<Property> properties) {
         this.name = name;
@@ -268,7 +272,9 @@ public class Device implements Serializable {
 
         Device device = (Device) o;
 
-        return getDeviceIdentifier().equals(device.getDeviceIdentifier());
+        if (getDeviceIdentifier().equals(device.getDeviceIdentifier())) return true;
+
+        return getId() == device.getId();
 
     }
 

components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/main/java/io/entgra/device/mgt/core/device/mgt/core/dao/DeviceDAO.java

@@ -864,4 +864,10 @@ public interface DeviceDAO {
      * @throws DeviceManagementDAOException
      */
     int getCountOfDevicesNotInGroup(PaginationRequest request, int tenantId) throws DeviceManagementDAOException;
+
+    List<Integer> getDevicesNotInGivenIdList(PaginationRequest request, List<Integer> deviceIds, int tenantId)
+            throws DeviceManagementDAOException;
+
+    List<Device> getDevicesByDeviceIds(PaginationRequest paginationRequest, List<Integer> deviceIds, int tenantId)
+            throws DeviceManagementDAOException;
 }

components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/main/java/io/entgra/device/mgt/core/device/mgt/core/dao/impl/AbstractDeviceDAOImpl.java

@@ -54,6 +54,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.StringJoiner;
 import java.util.Random;
+import java.util.stream.Collectors;
 
 public abstract class AbstractDeviceDAOImpl implements DeviceDAO {
 
@@ -3298,4 +3299,97 @@ public abstract class AbstractDeviceDAOImpl implements DeviceDAO {
             throw new DeviceManagementDAOException(msg, e);
         }
     }
+
+    @Override
+    public List<Integer> getDevicesNotInGivenIdList(PaginationRequest request, List<Integer> deviceIds, int tenantId)
+            throws DeviceManagementDAOException {
+        List<Integer> filteredDeviceIds = new ArrayList<>();
+        String deviceIdStringList = deviceIds.stream().map(String::valueOf).collect(Collectors.joining(","));
+        try {
+            Connection connection = getConnection();
+            String sql = "SELECT ID AS DEVICE_ID FROM DM_DEVICE WHERE ID NOT IN " +
+                    "(" + deviceIdStringList + ") LIMIT ? OFFSET ?";
+            try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
+                preparedStatement.setInt(1, request.getRowCount());
+                preparedStatement.setInt(2, request.getStartIndex());
+                try (ResultSet resultSet = preparedStatement.executeQuery()) {
+                    while (resultSet.next()) {
+                        filteredDeviceIds.add(resultSet.getInt("DEVICE_ID"));
+                    }
+                }
+                return filteredDeviceIds;
+            }
+        } catch (SQLException e) {
+            String msg = "Error occurred while retrieving device ids not in: " + filteredDeviceIds;
+            log.error(msg, e);
+            throw new DeviceManagementDAOException(msg, e);
+        }
+    }
+
+    @Override
+    public List<Device> getDevicesByDeviceIds(PaginationRequest paginationRequest, List<Integer> deviceIds, int tenantId)
+            throws DeviceManagementDAOException {
+        List<Device> devices = new ArrayList<>();
+        String deviceIdStringList = deviceIds.stream().map(String::valueOf).collect(Collectors.joining(","));
+        boolean isOwnerProvided = false;
+        boolean isDeviceStatusProvided = false;
+        boolean isDeviceNameProvided = false;
+        try {
+            Connection connection = getConnection();
+            String sql = "SELECT e.DEVICE_ID, d.DEVICE_IDENTIFICATION, e.STATUS, e.OWNER, d.NAME AS DEVICE_NAME, " +
+                    "e.DEVICE_TYPE FROM DM_DEVICE d INNER JOIN DM_ENROLMENT e " +
+                    "WHERE d.ID = e.DEVICE_ID AND d.TENANT_ID = ? AND e.DEVICE_ID IN (" + deviceIdStringList+ ") " +
+                    "AND e.STATUS NOT IN ('DELETED', 'REMOVED')";
+
+            if (paginationRequest.getOwner() != null) {
+                sql = sql + " AND e.OWNER = ?";
+                isOwnerProvided = true;
+            }
+
+            if (paginationRequest.getDeviceStatus() != null) {
+                sql = sql + " AND e.STATUS = ?";
+                isDeviceStatusProvided = true;
+            }
+
+            if (paginationRequest.getDeviceName() != null) {
+                sql = sql + " AND d.DEVICE_NAME = ?";
+                isDeviceNameProvided = true;
+            }
+
+            int parameterIdx = 1;
+            try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
+
+                preparedStatement.setInt(parameterIdx++, tenantId);
+
+                if (isOwnerProvided)
+                    preparedStatement.setString(parameterIdx++, paginationRequest.getOwner());
+                if (isDeviceStatusProvided)
+                    preparedStatement.setString(parameterIdx++, paginationRequest.getDeviceStatus());
+                if (isDeviceNameProvided)
+                    preparedStatement.setString(parameterIdx, paginationRequest.getDeviceName());
+
+                try(ResultSet resultSet = preparedStatement.executeQuery()) {
+                    Device device;
+                    while(resultSet.next()) {
+                        device = new Device();
+                        device.setId(resultSet.getInt("DEVICE_ID"));
+                        device.setDeviceIdentifier(resultSet.getString("DEVICE_IDENTIFICATION"));
+                        device.setName(resultSet.getString("DEVICE_NAME"));
+                        device.setType(resultSet.getString("DEVICE_TYPE"));
+                        EnrolmentInfo enrolmentInfo = new EnrolmentInfo();
+                        enrolmentInfo.setStatus(EnrolmentInfo.Status.valueOf(resultSet.getString("STATUS")));
+                        enrolmentInfo.setOwner(resultSet.getString("OWNER"));
+                        device.setEnrolmentInfo(enrolmentInfo);
+                        devices.add(device);
+                    }
+                }
+            }
+            return devices;
+        } catch (SQLException e) {
+            String msg = "Error occurred while retrieving devices for device ids in: " + deviceIds;
+            log.error(msg, e);
+            throw new DeviceManagementDAOException(msg, e);
+        }
+    }
+
 }

components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/main/java/io/entgra/device/mgt/core/device/mgt/core/dao/impl/AbstractEnrollmentDAOImpl.java

@@ -624,13 +624,6 @@ public abstract class AbstractEnrollmentDAOImpl implements EnrollmentDAO {
 
                 try (ResultSet rs = stmt.executeQuery()) {
                     while (rs.next()) {
-                        if (ownerDetails.getUserName() == null) {
-                            ownerDetails.setUserName(rs.getString("OWNER"));
-                        }
-                        ownerDetails.setDeviceStatus(rs.getString("DEVICE_STATUS"));
-                        ownerDetails.setDeviceNames(rs.getString("DEVICE_NAME"));
-                        ownerDetails.setDeviceTypes(rs.getString("DEVICE_TYPE"));
-                        ownerDetails.setDeviceIdentifiers(rs.getString("DEVICE_IDENTIFICATION"));
                         deviceIds.add(rs.getInt("DEVICE_ID"));
                         deviceCount++;
                     }
@@ -641,11 +634,95 @@ public abstract class AbstractEnrollmentDAOImpl implements EnrollmentDAO {
             log.error(msg, e);
             throw new DeviceManagementDAOException(msg, e);
         }
+        ownerDetails.setUserName(deviceOwner);
         ownerDetails.setDeviceIds(deviceIds);
         ownerDetails.setDeviceCount(deviceCount);
         return ownerDetails;
     }
 
+//    @Override
+//    public OwnerWithDeviceDTO getOwnersWithDevices(String owner, List<String> allowingDeviceStatuses, int tenantId,
+//                                                   int deviceTypeId, String deviceOwner, String deviceName,
+//                                                   String deviceStatus) throws DeviceManagementDAOException {
+//        Connection conn = null;
+//        OwnerWithDeviceDTO ownerDetails = new OwnerWithDeviceDTO();
+//        List<Integer> deviceIds = new ArrayList<>();
+//        int deviceCount = 0;
+//
+//        StringBuilder deviceFilters = new StringBuilder();
+//        for (int i = 0; i < allowingDeviceStatuses.size(); i++) {
+//            deviceFilters.append("?");
+//            if (i < allowingDeviceStatuses.size() - 1) {
+//                deviceFilters.append(",");
+//            }
+//        }
+//
+//        StringBuilder sql = new StringBuilder(
+//                "SELECT e.DEVICE_ID, " +
+//                        "e.OWNER, " +
+//                        "e.STATUS AS DEVICE_STATUS, " +
+//                        "d.NAME AS DEVICE_NAME, " +
+//                        "e.DEVICE_TYPE AS DEVICE_TYPE, " +
+//                        "e.DEVICE_IDENTIFICATION AS DEVICE_IDENTIFICATION " +
+//                "FROM DM_ENROLMENT e " +
+//                "JOIN DM_DEVICE d ON e.DEVICE_ID = d.ID " +
+//                "WHERE e.OWNER = ? AND e.TENANT_ID = ? AND d.DEVICE_TYPE_ID = ? AND e.STATUS IN (" + deviceFilters + ")");
+//
+//        if (deviceOwner != null && !deviceOwner.isEmpty()) {
+//            sql.append(" AND e.OWNER LIKE ?");
+//        }
+//        if (deviceName != null && !deviceName.isEmpty()) {
+//            sql.append(" AND d.NAME LIKE ?");
+//        }
+//        if (deviceStatus != null && !deviceStatus.isEmpty()) {
+//            sql.append(" AND e.STATUS = ?");
+//        }
+//
+//        try {
+//            conn = this.getConnection();
+//            try (PreparedStatement stmt = conn.prepareStatement(sql.toString())) {
+//                int index = 1;
+//                stmt.setString(index++, owner);
+//                stmt.setInt(index++, tenantId);
+//                stmt.setInt(index++, deviceTypeId);
+//                for (String status : allowingDeviceStatuses) {
+//                    stmt.setString(index++, status);
+//                }
+//
+//                if (deviceOwner != null && !deviceOwner.isEmpty()) {
+//                    stmt.setString(index++, "%" + deviceOwner + "%");
+//                }
+//                if (deviceName != null && !deviceName.isEmpty()) {
+//                    stmt.setString(index++, "%" + deviceName + "%");
+//                }
+//                if (deviceStatus != null && !deviceStatus.isEmpty()) {
+//                    stmt.setString(index++, deviceStatus);
+//                }
+//
+//                try (ResultSet rs = stmt.executeQuery()) {
+//                    while (rs.next()) {
+//                        if (ownerDetails.getUserName() == null) {
+//                            ownerDetails.setUserName(rs.getString("OWNER"));
+//                        }
+//                        ownerDetails.setDeviceStatus(rs.getString("DEVICE_STATUS"));
+//                        ownerDetails.setDeviceNames(rs.getString("DEVICE_NAME"));
+//                        ownerDetails.setDeviceTypes(rs.getString("DEVICE_TYPE"));
+//                        ownerDetails.setDeviceIdentifiers(rs.getString("DEVICE_IDENTIFICATION"));
+//                        deviceIds.add(rs.getInt("DEVICE_ID"));
+//                        deviceCount++;
+//                    }
+//                }
+//            }
+//        } catch (SQLException e) {
+//            String msg = "Error occurred while retrieving owners and device IDs for owner: " + owner;
+//            log.error(msg, e);
+//            throw new DeviceManagementDAOException(msg, e);
+//        }
+//        ownerDetails.setDeviceIds(deviceIds);
+//        ownerDetails.setDeviceCount(deviceCount);
+//        return ownerDetails;
+//    }
+
     @Override
     public OwnerWithDeviceDTO getOwnerWithDeviceByDeviceId(int deviceId, int tenantId, String deviceOwner, String deviceName,
                                                            String deviceStatus) throws DeviceManagementDAOException {

components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/main/java/io/entgra/device/mgt/core/device/mgt/core/dao/impl/device/GenericDeviceDAOImpl.java

@@ -457,6 +457,7 @@ public class GenericDeviceDAOImpl extends AbstractDeviceDAOImpl {
                     "e.ID AS ENROLMENT_ID " +
                     "FROM DM_ENROLMENT e, " +
                     "(SELECT d.ID, " +
+                    "d.LAST_UPDATED_TIMESTAMP, " +
                     "d.DEVICE_IDENTIFICATION " +
                     "FROM DM_DEVICE d WHERE d.TENANT_ID = ?) d1 " +
                     "WHERE d1.ID = e.DEVICE_ID AND e.TENANT_ID = ? ";

components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/main/java/io/entgra/device/mgt/core/device/mgt/core/service/DeviceManagementProviderService.java

@@ -1152,4 +1152,10 @@ public interface DeviceManagementProviderService {
      */
     Device updateDeviceName(Device device, String deviceType, String deviceId)
             throws DeviceManagementException, DeviceNotFoundException, ConflictException;
+
+    List<Integer> getDevicesNotInGivenIdList(List<Integer> deviceIds, PaginationRequest paginationRequest)
+            throws DeviceManagementException;
+
+    List<Device> getDevicesByDeviceIds(PaginationRequest paginationRequest, List<Integer> deviceIds)
+            throws DeviceManagementException;
 }

components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/main/java/io/entgra/device/mgt/core/device/mgt/core/service/DeviceManagementProviderServiceImpl.java

@@ -161,6 +161,7 @@ import javax.xml.bind.Marshaller;
 import java.io.IOException;
 import java.io.StringWriter;
 import java.lang.reflect.Type;
+import java.sql.Array;
 import java.sql.SQLException;
 import java.sql.Timestamp;
 import java.time.LocalDateTime;
@@ -5359,25 +5360,13 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
         int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true);
         OwnerWithDeviceDTO ownerWithDeviceDTO;
 
-        List<String> allowingDeviceStatuses = new ArrayList<>();
+        List<String> allowingDeviceStatuses = Arrays.asList(EnrolmentInfo.Status.ACTIVE.toString(),
-        allowingDeviceStatuses.add(EnrolmentInfo.Status.ACTIVE.toString());
+                EnrolmentInfo.Status.INACTIVE.toString(), EnrolmentInfo.Status.UNREACHABLE.toString());
-        allowingDeviceStatuses.add(EnrolmentInfo.Status.INACTIVE.toString());
-        allowingDeviceStatuses.add(EnrolmentInfo.Status.UNREACHABLE.toString());
 
         try {
             DeviceManagementDAOFactory.openConnection();
-            ownerWithDeviceDTO = this.enrollmentDAO.getOwnersWithDevices(owner, allowingDeviceStatuses, tenantId, deviceTypeId, deviceOwner, deviceName, deviceStatus);
+            ownerWithDeviceDTO = this.enrollmentDAO.getOwnersWithDevices(owner, allowingDeviceStatuses,
-            if (ownerWithDeviceDTO == null) {
+                    tenantId, deviceTypeId, deviceOwner, deviceName, deviceStatus);
-                String msg = "No data found for owner: " + owner;
-                log.error(msg);
-                throw new DeviceManagementDAOException(msg);
-            }
-            List<Integer> deviceIds = ownerWithDeviceDTO.getDeviceIds();
-            if (deviceIds != null) {
-                ownerWithDeviceDTO.setDeviceCount(deviceIds.size());
-            } else {
-                ownerWithDeviceDTO.setDeviceCount(0);
-            }
         } catch (DeviceManagementDAOException | SQLException e) {
             String msg = "Error occurred while retrieving device IDs for owner: " + owner;
             log.error(msg, e);
@@ -5388,6 +5377,41 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
         return ownerWithDeviceDTO;
     }
 
+//    @Override
+//    public OwnerWithDeviceDTO getOwnersWithDeviceIds(String owner, int deviceTypeId, String deviceOwner, String deviceName, String deviceStatus)
+//            throws DeviceManagementDAOException {
+//        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true);
+//        OwnerWithDeviceDTO ownerWithDeviceDTO;
+//
+//        List<String> allowingDeviceStatuses = new ArrayList<>();
+//        allowingDeviceStatuses.add(EnrolmentInfo.Status.ACTIVE.toString());
+//        allowingDeviceStatuses.add(EnrolmentInfo.Status.INACTIVE.toString());
+//        allowingDeviceStatuses.add(EnrolmentInfo.Status.UNREACHABLE.toString());
+//
+//        try {
+//            DeviceManagementDAOFactory.openConnection();
+//            ownerWithDeviceDTO = this.enrollmentDAO.getOwnersWithDevices(owner, allowingDeviceStatuses, tenantId, deviceTypeId, deviceOwner, deviceName, deviceStatus);
+//            if (ownerWithDeviceDTO == null) {
+//                String msg = "No data found for owner: " + owner;
+//                log.error(msg);
+//                throw new DeviceManagementDAOException(msg);
+//            }
+//            List<Integer> deviceIds = ownerWithDeviceDTO.getDeviceIds();
+//            if (deviceIds != null) {
+//                ownerWithDeviceDTO.setDeviceCount(deviceIds.size());
+//            } else {
+//                ownerWithDeviceDTO.setDeviceCount(0);
+//            }
+//        } catch (DeviceManagementDAOException | SQLException e) {
+//            String msg = "Error occurred while retrieving device IDs for owner: " + owner;
+//            log.error(msg, e);
+//            throw new DeviceManagementDAOException(msg, e);
+//        } finally {
+//            DeviceManagementDAOFactory.closeConnection();
+//        }
+//        return ownerWithDeviceDTO;
+//    }
+
 
     @Override
     public OwnerWithDeviceDTO getOwnerWithDeviceByDeviceId(int deviceId, String deviceOwner, String deviceName, String deviceStatus)
@@ -5568,4 +5592,57 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
             DeviceManagementDAOFactory.closeConnection();
         }
     }
+
+    @Override
+    public List<Integer> getDevicesNotInGivenIdList(List<Integer> deviceIds, PaginationRequest paginationRequest)
+            throws DeviceManagementException {
+
+        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
+        if (paginationRequest == null) {
+            String msg = "Received null for pagination request";
+            log.error(msg);
+            throw new DeviceManagementException(msg);
+        }
+
+        try {
+            DeviceManagementDAOFactory.openConnection();
+            return deviceDAO.getDevicesNotInGivenIdList(paginationRequest, deviceIds, tenantId);
+        } catch (DeviceManagementDAOException e) {
+            String msg = "Error encountered while getting device ids";
+            log.error(msg, e);
+            throw new DeviceManagementException(msg, e);
+        } catch (SQLException e) {
+            String msg = "Error encountered while getting the database connection";
+            log.error(msg, e);
+            throw new DeviceManagementException(msg, e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Override
+    public List<Device> getDevicesByDeviceIds(PaginationRequest paginationRequest, List<Integer> deviceIds)
+            throws DeviceManagementException {
+        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
+        if (paginationRequest == null) {
+            String msg = "Received null for pagination request";
+            log.error(msg);
+            throw new DeviceManagementException(msg);
+        }
+
+        try {
+            DeviceManagementDAOFactory.openConnection();
+            return deviceDAO.getDevicesByDeviceIds(paginationRequest, deviceIds, tenantId);
+        } catch (DeviceManagementDAOException e) {
+            String msg = "Error encountered while getting devices for device ids in " + deviceIds;
+            log.error(msg, e);
+            throw new DeviceManagementException(msg, e);
+        } catch (SQLException e) {
+            String msg = "Error encountered while getting the database connection";
+            log.error(msg, e);
+            throw new DeviceManagementException(msg, e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
 }