Refactor code

+
+    public static void init(CEADatasourceConfiguration ceaDatasourceConfiguration) {
+        dataSource = resolveDatasource(ceaDatasourceConfiguration);
+        if (dataSource == null) throw new NullPointerException("Datasource is null");

+    }
+
+    private static DataSource resolveDatasource(CEADatasourceConfiguration ceaDatasourceConfiguration) {
+        if (ceaDatasourceConfiguration == null)

+        if (ceaDatasourceConfiguration == null)
+            throw new NullPointerException("Null is retrieved for Datasource configuration");
+        JNDILookupDefinition jndiLookupDefinition = ceaDatasourceConfiguration.getJndiLookupDefinition();
+        if (jndiLookupDefinition == null)

+        String datasourceName = jndiLookupDefinition.getJndiName();
+        List<JNDILookupDefinition.JNDIProperty>
+                jndiProperties = ceaDatasourceConfiguration.getJndiLookupDefinition().getJndiProperties();
+        if (jndiProperties == null || jndiProperties.isEmpty()) return lookupDatasource(datasourceName);

+    }
+
+    public static CEAPolicyDAO getCEAPolicyDAO() {
+        if (productName == null) throw new IllegalStateException("Database is not initialized properly");

+import org.wso2.carbon.context.PrivilegedCarbonContext;
+
+import java.nio.charset.StandardCharsets;
+import java.sql.*;

+    }
+
+    private CEAPolicyDTO toCEAPolicyDTO(CEAPolicy ceaPolicy) {
+        if (ceaPolicy == null) throw new NullPointerException("CEAPolicy can't be null");

+        ceaPolicyDTO.setCreatedTimestamp(new Timestamp(ceaPolicy.getCreated().getTime()));
+        ceaPolicyDTO.setUpdatedTimestamp(new Timestamp(ceaPolicy.getLastUpdated().getTime()));
+        ceaPolicyDTO.setTenantId(ceaPolicy.getTenantId());
+        if (ceaPolicy.getLastSynced() != null)

+    }
+
+    private CEAPolicy toCEAPolicy(CEAPolicyDTO ceaPolicyDTO) {
+        if (ceaPolicyDTO == null) throw new NullPointerException("CEAPolicyDTO can't be null");

+        ceaPolicy.setLastUpdated(new Date(ceaPolicyDTO.getUpdatedTimestamp().getTime()));
+        ceaPolicy.setSynced(ceaPolicyDTO.isSynced());
+        ceaPolicy.setTenantId(ceaPolicyDTO.getTenantId());
+        if (ceaPolicyDTO.getLastSyncedTimestamp() != null)

+    private EnforcementServiceManager enforcementServiceManager;
+    private TaskService taskService;
+    private CEAPolicyMonitoringTaskManager ceaPolicyMonitoringTaskManager;
+    CEAManagementDataHolder() {

+                    getInstance().getCeaPolicyMonitoringTaskManager();
+            CEAConfigManager ceaConfigManager = CEAConfigManager.getInstance();
+            CEAConfiguration ceaConfiguration = ceaConfigManager.getCeaConfiguration();
+            if (ceaPolicyMonitoringTaskManager == null)

+            CEAPolicyAlreadyExistsException {
+        try {
+            CEAPolicyManagementDAOFactory.openConnection();
+            if (ceaPolicyDAO.retrieveCEAPolicy() != null) {

+        try {
+            CEAPolicyManagementDAOFactory.openConnection();
+            CEAPolicy existingCeaPolicy = ceaPolicyDAO.retrieveCEAPolicy();
+            if (existingCeaPolicy == null) throw new CEAPolicyNotFoundException("CEA policy not found");

+        try {
+            CEAPolicyMonitoringTaskManager ceaPolicyMonitoringTaskManager = CEAManagementDataHolder.
+                    getInstance().getCeaPolicyMonitoringTaskManager();
+            if (ceaPolicyMonitoringTaskManager == null)

+                throw new IllegalStateException("CEA policy monitoring task manager not initialized properly");
+            CEAPolicyManagementDAOFactory.openConnection();
+            CEAPolicy existingCeaPolicy = ceaPolicyDAO.retrieveCEAPolicy();
+            if (existingCeaPolicy == null) throw new CEAPolicyNotFoundException("CEA policy not found");

+
+    @Override
+    public void startTask(long monitoringFrequency) throws CEAPolicyMonitoringTaskManagerException {
+        if (monitoringFrequency <= 0) throw new CEAPolicyMonitoringTaskManagerException("Invalid monitoring frequency");

+        if (monitoringFrequency <= 0) throw new CEAPolicyMonitoringTaskManagerException("Invalid monitoring frequency");
+
+        TaskService taskService = CEAManagementDataHolder.getInstance().getTaskService();
+        if (taskService == null) throw new IllegalStateException("Task service is not initialized");

+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import io.entgra.device.mgt.core.cea.mgt.common.bean.*;

+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.*;

+        Set<EmailOutlookAccessPolicy> emailOutlookAccessPolicies = ceaPolicy.getAccessPolicy().getEmailOutlookAccessPolicy();
+        if (emailOutlookAccessPolicies.contains(EmailOutlookAccessPolicy.NOT_CONFIGURED)) {
+            if (log.isDebugEnabled()) {
+                log.info("CEA email outlook policy not configured, but the support is available in " +

+        if (ceaPolicy.getAccessPolicy().getPOPIMAPAccessPolicy().
+                equalsName(EmailOutlookAccessPolicy.NOT_CONFIGURED.name())) {
+            if (log.isDebugEnabled()) {
+                log.info("CEA POP/IMAP policy not configured, but support is available in " +

+        if (ceaPolicy.getAccessPolicy().getWebOutlookAccessPolicy().
+                equalsName(WebOutlookAccessPolicy.NOT_CONFIGURED.name())) {
+            if (log.isDebugEnabled()) {
+                log.info("CEA Outlook web access policy not configured, but support is available in " +

+            throw new CEAEnforcementException(msg);
+        }
+
+        if (powershellResponse.getResponseBody() == null) return Collections.emptyList();

+
+package io.entgra.device.mgt.core.cea.mgt.enforce.Impl.gateway;
+
+import com.microsoft.aad.msal4j.*;

+import org.apache.commons.logging.LogFactory;
+
+import java.net.MalformedURLException;
+import java.util.*;

+import org.wso2.carbon.user.api.UserStoreManager;
+import org.wso2.carbon.user.core.service.RealmService;
+
+import java.util.*;

+            throw new IllegalStateException(msg);
+        }
+        List<Device> devices = deviceManagementProviderService.getEnrolledDevicesSince(since);
+        if (devices == null) return new ArrayList<>();

+            throw new IllegalStateException(msg);
+        }
+        List<Device> devices = deviceManagementProviderService.getEnrolledDevicesPriorTo(priorTo);
+        if (devices == null) return new ArrayList<>();

+import io.entgra.device.mgt.core.cea.mgt.enforce.exception.PowershellExecutionException;
+import io.entgra.device.mgt.core.cea.mgt.enforce.util.shell.Powershell;
+
+import java.io.*;

+import io.entgra.device.mgt.core.device.mgt.api.jaxrs.beans.CEAPolicyWrapper;
+import io.entgra.device.mgt.core.device.mgt.api.jaxrs.beans.ErrorResponse;
+import io.entgra.device.mgt.core.device.mgt.api.jaxrs.util.Constants;
+import io.swagger.annotations.*;

+import io.entgra.device.mgt.core.device.mgt.api.jaxrs.util.Constants;
+import io.swagger.annotations.*;
+
+import javax.ws.rs.*;

+
+package io.entgra.device.mgt.core.device.mgt.api.jaxrs.service.impl.admin;
+
+import io.entgra.device.mgt.core.cea.mgt.common.bean.*;

+package io.entgra.device.mgt.core.device.mgt.api.jaxrs.service.impl.admin;
+
+import io.entgra.device.mgt.core.cea.mgt.common.bean.*;
+import io.entgra.device.mgt.core.cea.mgt.common.bean.enums.*;

+import org.apache.commons.logging.LogFactory;
+import org.apache.http.HttpStatus;
+
+import javax.ws.rs.*;

+    private List<ActiveSyncServerUIConfiguration> constructActiveSyncServerConfigurations
+            (List<ServerUIConfiguration> serverUIConfigurations) {
+        List<ActiveSyncServerUIConfiguration> activeSyncServerUIConfigurations = new ArrayList<>();
+        if (serverUIConfigurations == null) return activeSyncServerUIConfigurations;

+import java.util.Date;
+import java.util.List;
+
+public interface CEAPolicyDAO {

+    }
+
+    public static void beginTransaction() throws CEAPolicyManagementDAOException {
+        Connection connection = currentConnection.get();

+            preparedStatement.setInt(1, tenantId);
+            try (ResultSet resultSet = preparedStatement.executeQuery()) {
+                while (resultSet.next()) {
+                    CEAPolicyDTO ceaPolicyDTO = new CEAPolicyDTO();

+        try (PreparedStatement preparedStatement = connection.prepareStatement(query)) {
+            try (ResultSet resultSet = preparedStatement.executeQuery()) {
+                while (resultSet.next()) {
+                    CEAPolicyDTO ceaPolicyDTO = new CEAPolicyDTO();

+        if (ceaPolicy == null) throw new NullPointerException("CEAPolicy can't be null");
+        CEAPolicyDTO ceaPolicyDTO = new CEAPolicyDTO();
+        CEAPolicyContent ceaPolicyContent = new CEAPolicyContent();
+        Gson gson = new Gson();

+    private CEAPolicy toCEAPolicy(CEAPolicyDTO ceaPolicyDTO) {
+        if (ceaPolicyDTO == null) throw new NullPointerException("CEAPolicyDTO can't be null");
+        CEAPolicy ceaPolicy = new CEAPolicy();
+        Gson gson = new Gson();

+        }
+    }
+
+    protected void setDataSourceService(DataSourceService dataSourceService) {

+        ceaPolicyDAO = CEAPolicyManagementDAOFactory.getCEAPolicyDAO();
+    }
+
+    public static CEAManagerImpl getInstance() {

+                    getInstance().getCeaPolicyMonitoringTaskManager();
+            CEAConfigManager ceaConfigManager = CEAConfigManager.getInstance();
+            CEAConfiguration ceaConfiguration = ceaConfigManager.getCeaConfiguration();
+            if (ceaPolicyMonitoringTaskManager == null)

+            CEAPolicyMonitoringTaskManager ceaPolicyMonitoringTaskManager = CEAManagementDataHolder.
+                    getInstance().getCeaPolicyMonitoringTaskManager();
+            if (ceaPolicyMonitoringTaskManager == null)
+                throw new IllegalStateException("CEA policy monitoring task manager not initialized properly");

+    }
+
+    @Override
+    public void enforce() throws CEAPolicyOperationException {

+        powershell = Powershell.getPowershell();
+    }
+
+    public static ExchangeOnlineCEAEnforcementServiceImpl getInstance() throws UnsupportedOsException {

+            List<MailboxProfile> mailboxProfiles = generateMailboxPolicies(validActiveSyncDevices,
+                    notValidActiveSyncDevices);
+            for (MailboxProfile mailboxProfile : mailboxProfiles) {
+                PowershellCommand powershellCommand = getCommand(Parser.COMMAND_SetCASMailbox.COMMAND, activeSyncServer);

+                                                         List<ActiveSyncDevice> activeSyncBlockedDevices) {
+        List<MailboxProfile> mailboxProfiles = new ArrayList<>();
+        for (ActiveSyncDevice activeSyncDevice : activeSyncAllowedDevices) {
+            MailboxProfile mailboxProfile = new MailboxProfile();

+        }
+
+        for (ActiveSyncDevice activeSyncDevice : activeSyncBlockedDevices) {
+            MailboxProfile mailboxProfile = new MailboxProfile();

+    private List<ActiveSyncDevice> constructActiveSyncDeviceList(PowershellResponse powershellResponse)
+            throws CEAEnforcementException {
+        if (powershellResponse == null) {
+            String msg = "Powershell response can't be null";

+        }
+
+        if (!powershellResponse.isSuccess()) {
+            String msg = "Powershell request failed while getting active sync devices";

+        if (powershellResponse.getResponseBody() == null) return Collections.emptyList();
+
+        if (!powershellResponse.getResponseBody().isJsonArray()) {
+            String msg = "Unexpected result retrieve when getting active sync devices";

+        for (JsonElement element : elements) {
+            try {
+                JsonObject deviceJsonObject = element.getAsJsonObject();
+                ActiveSyncDevice activeSyncDevice = new ActiveSyncDevice();

+
+public interface Powershell {
+    String OS = System.getProperty("os.name").toLowerCase();
+    boolean IS_UNIX = (OS.indexOf("nix") >= 0 || OS.indexOf("nux") >= 0 || OS.indexOf("aix") > 0);

     }
 
+    public static CEAManagementService getCEAManagementService() {
+        PrivilegedCarbonContext ctx = PrivilegedCarbonContext.getThreadLocalCarbonContext();

+/*
+ * Copyright (c) 2018 - 2023, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.

+        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
+        ceaPolicy.setTenantId(tenantId);
+        CEAPolicyDTO ceaPolicyDTO = toCEAPolicyDTO(ceaPolicy);
+        String query = "INSERT INTO DM_CEA_POLICIES (POLICY_CONTENT, CREATED_TIMESTAMP, UPDATED_TIMESTAMP, TENANT_ID) " +

+
+    private CEAPolicy toCEAPolicy(CEAPolicyDTO ceaPolicyDTO) {
+        if (ceaPolicyDTO == null) {
+            throw new NullPointerException("CEAPolicyDTO can't be null");

+                        "hence aborting CEA policy deleting procedure";
+                throw new IllegalStateException(msg);
+            }
+            CEAPolicyManagementDAOFactory.openConnection();

+            }
+
+        } catch (CEAManagementException e) {
+            String msg = "Error occurred while executing dynamic partitioned task for the CEA policy monitoring";

+            String msg = "Error occurred while executing dynamic partitioned task for the CEA policy monitoring";
+            log.error(msg, e);
+        } catch (CEAConfigManagerException e) {
+            String msg = "Error occurred while retrieving CEA configuration";

+            ceaPolicyOperation.enforce();
+            status = true;
+        } catch (EnforcementServiceManagerException | CEAPolicyOperationException e) {
+            String msg = "Error occurred while enforcing the CEA access policy for the tenant id" + ceaPolicy.getTenantId();

+        try {
+            ceaManager.updateSyncStatus(status, syncedStartTime);
+        } catch (CEAManagementException e) {
+            String msg = "Error occurred while recording sync status";

+    }
+
+    @Enforce
+    public void enforceConditionalAccessPolicy(CEAPolicy ceaPolicy) throws CEAEnforcementException {

+        }
+    }
+
+    private PowershellCommand getCommand(String command, ActiveSyncServer activeSyncServer)

+        return commandBuilder.build();
+    }
+
+    private PowershellCommand toAllMailboxesCommand(PowershellCommand command,

+        return getEXOMailbox;
+    }
+
+    private PowershellRequest getPowershellRequest(PowershellCommand command) {

+        return powershellRequest;
+    }
+
+    private List<MailboxProfile> generateMailboxPolicies(List<ActiveSyncDevice> activeSyncAllowedDevices,

+        return mailboxProfiles;
+    }
+
+    private List<ActiveSyncDevice> constructActiveSyncDeviceList(PowershellResponse powershellResponse)

+        return activeSyncDevices;
+    }
+
+    private List<ActiveSyncDevice> getConnectedActiveSyncDevicesAfter(Date after, ActiveSyncServer activeSyncServer)

+        return constructActiveSyncDeviceList(powershellResponse);
+    }
+
+    private List<ActiveSyncDevice> getConnectedActiveSyncDevicesBefore(Date before, ActiveSyncServer activeSyncServer)

+        return constructActiveSyncDeviceList(powershellResponse);
+    }
+
+    private List<ActiveSyncDevice> getAllConnectedActiveSyncDevices(ActiveSyncServer activeSyncServer)

+        }
+    }
+
+    private IConfidentialClientApplication getOrCreateConfidentialClientApplication(String clientId, String secret, String authority)

+public class DeviceMgtUtil {
+    private static final Log log = LogFactory.getLog(DeviceMgtUtil.class);
+
+    public static List<ActiveSyncDevice> getEnrolledActiveSyncDevicesSince(Date since)

+        return DeviceMgtUtil.constructActiveSyncDeviceList(devices);
+    }
+
+    private static DeviceManagementProviderService getDeviceManagementProviderService() {

+        return realmService.getTenantUserRealm(tenantId).getUserStoreManager();
+    }
+
+    private static String getIdentity(String owner, UserStoreManager userStoreManager)

+        return userStoreManager.getUserClaimValue(owner, Constants.EMAIL_CLAIM_URI, null);
+    }
+
+    private static List<ActiveSyncDevice> constructActiveSyncDeviceList(List<Device> devices)

+        return activeSyncDevices;
+    }
+
+    public static ActiveSyncDevice mapToActiveSyncDevice(Device device, UserStoreManager userStoreManager)

+            return constructResponse(exitCode, getStringContent(standardOutputStringWriter),
+                    getStringContent(errorStringWriter));
+        } catch (IOException e) {
+            String msg = "IOException occurred while executing powershell command : "

+                    + powershellRequest.getCommand();
+            throw new PowershellExecutionException(msg, e);
+        } catch (InterruptedException e) {
+            String msg = "Thread got interrupted while executing powershell command : "

+    ) CEAPolicyWrapper ceaPolicyWrapper);
+
+    @GET
+    @Path("/syncNow")

+/*
+ * Copyright (c) 2018 - 2023, Entgra (Pvt) Ltd. (http://www.entgra.io) All Rights Reserved.

+    }
+
+    @GET
+    @Path("/syncNow")

+        }
+    }
+
+    private CEAPolicy constructCEAPolicy(CEAPolicyWrapper ceaPolicyWrapper) {

+        return ceaPolicy;
+    }
+
+    private List<ActiveSyncServerUIConfiguration> constructActiveSyncServerConfigurations

+        if (serverUIConfigurations == null) {
+            return activeSyncServerUIConfigurations;
+        }
+        for (ServerUIConfiguration serverUIConfiguration : serverUIConfigurations) {

+        validateCEAGracePeriod(ceaPolicyWrapper.getGracePeriodEntries());
+    }
+
+    public static void validateActiveSyncServer(ActiveSyncServer activeSyncServer) {

+        }
+    }
+
+    public static void validateCEAAccessPolicy(AccessPolicyWrapper accessPolicyWrapper) {

+        }
+    }
+
+    public static void validateCEAGracePeriod(GracePeriodWrapper gracePeriodWrapper) {