path: root/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/HandleIncomingNotifications.java

/*-
 * ============LICENSE_START=======================================================
 * ONAP-PAP-REST
 * ================================================================================
 * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
 * ================================================================================
 * Licensed 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.
 * ============LICENSE_END=========================================================
 */

package org.onap.policy.pap.xacml.rest.components;

import com.att.research.xacml.api.pap.PAPException;
import com.att.research.xacml.api.pap.PDPPolicy;
import com.att.research.xacml.util.XACMLProperties;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import javax.persistence.PersistenceException;
import org.apache.commons.io.FilenameUtils;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.onap.policy.common.logging.eelf.MessageCodes;
import org.onap.policy.common.logging.eelf.PolicyLogger;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.common.logging.flexlogger.Logger;
import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
import org.onap.policy.rest.XACMLRestProperties;
import org.onap.policy.rest.dao.PolicyDBException;
import org.onap.policy.rest.jpa.GroupEntity;
import org.onap.policy.rest.jpa.PdpEntity;
import org.onap.policy.rest.jpa.PolicyEntity;
import org.onap.policy.xacml.api.pap.OnapPDP;
import org.onap.policy.xacml.api.pap.OnapPDPGroup;
import org.onap.policy.xacml.std.pap.StdPDPGroup;
import org.onap.policy.xacml.std.pap.StdPDPPolicy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HandleIncomingNotifications {

    private static final Logger logger = FlexLogger.getLogger(HandleIncomingNotifications.class);

    private static final String POLICY_NOTIFICATION = "policy";
    private static final String PDP_NOTIFICATION = "pdp";
    private static final String GROUP_NOTIFICATION = "group";
    public static final String JSON_CONFIG = "JSON";
    public static final String XML_CONFIG = "XML";
    public static final String PROPERTIES_CONFIG = "PROPERTIES";
    public static final String OTHER_CONFIG = "OTHER";
    public static final String AUDIT_USER = "audit";


    private static SessionFactory sessionfactory;

    @Autowired
    public HandleIncomingNotifications(SessionFactory sessionfactory) {
        HandleIncomingNotifications.sessionfactory = sessionfactory;
    }

    public HandleIncomingNotifications() {
        // Default Constructor
    }

    public void handleIncomingHttpNotification(String url, String entityId, String entityType, String extraData,
            XACMLPapServlet xacmlPapServlet) {
        logger.info("DBDao url: " + url + " has reported an update on " + entityType + " entity " + entityId);
        PolicyDBDaoTransaction transaction = PolicyDBDao.getPolicyDBDaoInstance().getNewTransaction();
        // although its named retries, this is the total number of tries
        int retries;
        try {
            retries = Integer
                    .parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_INCOMINGNOTIFICATION_TRIES));
        } catch (Exception e) {
            logger.error("xacml.rest.pap.incomingnotification.tries property not set, using a default of 3." + e);
            retries = 3;
        }
        // if someone sets it to some dumb value, we need to make sure it will
        // try at least once
        if (retries < 1) {
            retries = 1;
        }
        int pauseBetweenRetries = 1000;
        switch (entityType) {

            case POLICY_NOTIFICATION:
                for (int i = 0; i < retries; i++) {
                    try {
                        handleIncomingPolicyChange(entityId);
                        break;
                    } catch (Exception e) {
                        logger.debug(e);
                        PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                                "Caught exception on handleIncomingPolicyChange(" + url + ", " + entityId + ", "
                                        + extraData + ")");
                    }
                    try {
                        Thread.sleep(pauseBetweenRetries);
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
                break;
            case PDP_NOTIFICATION:
                for (int i = 0; i < retries; i++) {
                    try {
                        handleIncomingPdpChange(entityId, transaction);
                        break;
                    } catch (Exception e) {
                        logger.debug(e);
                        PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                                "Caught exception on handleIncomingPdpChange(" + url + ", " + entityId + ", "
                                        + transaction + ")");
                    }
                    try {
                        Thread.sleep(pauseBetweenRetries);
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
                break;
            case GROUP_NOTIFICATION:
                for (int i = 0; i < retries; i++) {
                    try {
                        handleIncomingGroupChange(entityId, extraData, transaction);
                        break;
                    } catch (Exception e) {
                        logger.debug(e);
                        PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                                "Caught exception on handleIncomingGroupChange(" + url + ", " + entityId + ", "
                                        + extraData + ", " + transaction + ", " + xacmlPapServlet + ")");
                    }
                    try {
                        Thread.sleep(pauseBetweenRetries);
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
                break;
        }
        // no changes should be being made in this function, we still need to
        // close
        transaction.rollbackTransaction();
    }

    private void handleIncomingGroupChange(String groupId, String extraData, PolicyDBDaoTransaction transaction)
            throws PAPException, PolicyDBException {
        GroupEntity groupRecord = null;
        long groupIdLong = -1;
        try {
            groupIdLong = Long.parseLong(groupId);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("groupId " + groupId + " cannot be parsed into a long");
        }
        try {
            groupRecord = transaction.getGroup(groupIdLong);
        } catch (Exception e) {
            PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                    "Caught Exception trying to get pdp group record with transaction.getGroup(" + groupIdLong + ");");
            throw new PAPException("Could not get local group " + groupIdLong);
        }
        if (groupRecord == null) {
            throw new PersistenceException("The group record returned is null");
        }
        // compare to local fs
        // does group folder exist
        OnapPDPGroup localGroup = null;
        try {
            localGroup = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getGroup(groupRecord.getGroupId());
        } catch (Exception e) {
            logger.warn("Caught PAPException trying to get local pdp group with papEngine.getGroup(" + groupId + ");",
                    e);
        }
        if (localGroup == null && extraData != null) {
            // here we can try to load an old group id from the extraData
            try {
                localGroup = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getGroup(extraData);
            } catch (Exception e) {
                logger.warn(
                        "Caught PAPException trying to get local pdp group with papEngine.getGroup(" + extraData + ");",
                        e);
            }
        }
        if (localGroup != null && groupRecord.isDeleted()) {
            OnapPDPGroup newLocalGroup = null;
            if (extraData != null) {
                try {
                    newLocalGroup = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getGroup(extraData);
                } catch (PAPException e) {
                    PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                            "Caught PAPException trying to get new pdp group with papEngine.getGroup(" + extraData
                                    + ");");
                }
            }
            try {
                PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().removeGroup(localGroup, newLocalGroup);
            } catch (NullPointerException | PAPException e) {
                PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                        "Caught PAPException trying to get remove pdp group with papEngine.removeGroup(" + localGroup
                                + ", " + newLocalGroup + ");");
                throw new PAPException("Could not remove group " + groupId);
            }
        } else if (localGroup == null) {
            // creating a new group
            try {
                PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().newGroup(groupRecord.getgroupName(),
                        groupRecord.getDescription());
            } catch (NullPointerException | PAPException e) {
                PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                        "Caught PAPException trying to create pdp group with papEngine.newGroup(groupRecord.getgroupName(), groupRecord.getDescription());");
                throw new PAPException("Could not create group " + groupRecord);
            }
            try {
                localGroup = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getGroup(groupRecord.getGroupId());
            } catch (PAPException e1) {
                PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, PolicyDBDao.POLICYDBDAO_VAR,
                        "Caught PAPException trying to get pdp group we just created with papEngine.getGroup(groupRecord.getGroupId());\nAny PDPs or policies in the new group may not have been added");
                return;
            }
            // add possible pdps to group
            List<?> pdpsInGroup = transaction.getPdpsInGroup(Long.parseLong(groupRecord.getGroupId()));
            for (Object pdpO : pdpsInGroup) {
                PdpEntity pdp = (PdpEntity) pdpO;
                try {
                    PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().newPDP(pdp.getPdpId(), localGroup,
                            pdp.getPdpName(), pdp.getDescription(), pdp.getJmxPort());
                } catch (NullPointerException | PAPException e) {
                    PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                            "Caught PAPException trying to get create pdp with papEngine.newPDP(pdp.getPdpId(), localGroup, pdp.getPdpName(), pdp.getDescription(), pdp.getJmxPort());");
                    throw new PAPException("Could not create pdp " + pdp);
                }
            }
            // add possible policies to group (file system only, apparently)
        } else {
            if (!(localGroup instanceof StdPDPGroup)) {
                throw new PAPException("group is not a StdPDPGroup");
            }
            // clone the object
            // because it will be comparing the new group to its own version
            StdPDPGroup localGroupClone = new StdPDPGroup(localGroup.getId(), localGroup.isDefaultGroup(),
                    localGroup.getName(), localGroup.getDescription(), ((StdPDPGroup) localGroup).getDirectory());
            localGroupClone.setOnapPdps(localGroup.getOnapPdps());
            localGroupClone.setPipConfigs(localGroup.getPipConfigs());
            localGroupClone.setStatus(localGroup.getStatus());
            // we are updating a group or adding a policy or changing default
            // set default if it should be
            if (!localGroupClone.isDefaultGroup() && groupRecord.isDefaultGroup()) {
                try {
                    PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().setDefaultGroup(localGroup);
                    return;
                } catch (PAPException e) {
                    PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                            "Caught PAPException trying to set default group with papEngine.SetDefaultGroup("
                                    + localGroupClone + ");");
                    throw new PAPException("Could not set default group to " + localGroupClone);
                }
            }
            boolean needToUpdate = false;
            if (updateGroupPoliciesInFileSystem(localGroupClone, localGroup, groupRecord, transaction)) {
                needToUpdate = true;
            }
            if (!PolicyDBDao.stringEquals(localGroupClone.getId(), groupRecord.getGroupId())
                    || !PolicyDBDao.stringEquals(localGroupClone.getName(), groupRecord.getgroupName())) {
                // changing ids
                // we do not want to change the id, the papEngine will do this
                // for us, it needs to know the old id
                localGroupClone.setName(groupRecord.getgroupName());
                needToUpdate = true;
            }
            if (!PolicyDBDao.stringEquals(localGroupClone.getDescription(), groupRecord.getDescription())) {
                localGroupClone.setDescription(groupRecord.getDescription());
                needToUpdate = true;
            }
            if (needToUpdate) {
                try {
                    PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().updateGroup(localGroupClone);
                } catch (PAPException e) {
                    PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                            "Caught PAPException trying to update group with papEngine.updateGroup(" + localGroupClone
                                    + ");");
                    throw new PAPException("Could not update group " + localGroupClone);
                }
            }
        }
    }

    // this will also handle removes, since incoming pdpGroup has no policies
    // internally, we are just going to add them all in from the db
    private boolean updateGroupPoliciesInFileSystem(OnapPDPGroup pdpGroup, OnapPDPGroup oldPdpGroup,
            GroupEntity groupRecord, PolicyDBDaoTransaction transaction) throws PAPException, PolicyDBException {
        if (!(pdpGroup instanceof StdPDPGroup)) {
            throw new PAPException("group is not a StdPDPGroup");
        }
        StdPDPGroup group = (StdPDPGroup) pdpGroup;
        // this must always be true since we don't explicitly know when a delete
        // is occuring
        boolean didUpdate = true;
        HashMap<String, PDPPolicy> currentPolicySet = new HashMap<>(oldPdpGroup.getPolicies().size());
        HashSet<PDPPolicy> newPolicySet = new HashSet<>();
        for (PDPPolicy pdpPolicy : oldPdpGroup.getPolicies()) {
            currentPolicySet.put(pdpPolicy.getId(), pdpPolicy);
        }
        for (PolicyEntity policy : groupRecord.getPolicies()) {
            String pdpPolicyName =
                    PolicyDBDao.getPolicyDBDaoInstance().getPdpPolicyName(policy.getPolicyName(), policy.getScope());
            if (group.getPolicy(pdpPolicyName) == null) {
                didUpdate = true;
                if (currentPolicySet.containsKey(pdpPolicyName)) {
                    newPolicySet.add(currentPolicySet.get(pdpPolicyName));
                } else {
                    logger.info(
                            "PolicyDBDao: Adding the new policy to the PDP group after notification: " + pdpPolicyName);
                    InputStream policyStream = new ByteArrayInputStream(policy.getPolicyData().getBytes());
                    group.copyPolicyToFile(pdpPolicyName, policyStream);
                    ((StdPDPPolicy) (group.getPolicy(pdpPolicyName))).setName(PolicyDBDao.getPolicyDBDaoInstance()
                            .removeExtensionAndVersionFromPolicyName(pdpPolicyName));
                    try {
                        policyStream.close();
                    } catch (IOException e) {
                        didUpdate = false;
                        PolicyLogger.error(e.getMessage() + e);
                    }
                }
            }
        }
        logger.info("PolicyDBDao: Adding updated policies to group after notification.");
        if (didUpdate) {
            newPolicySet.addAll(group.getPolicies());
            group.setPolicies(newPolicySet);
        }
        return didUpdate;
    }

    private void handleIncomingPdpChange(String pdpId, PolicyDBDaoTransaction transaction) throws PAPException {
        // get pdp
        long pdpIdLong = -1;
        try {
            pdpIdLong = Long.parseLong(pdpId);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("pdpId " + pdpId + " cannot be parsed into a long");
        }
        PdpEntity pdpRecord = null;
        try {
            pdpRecord = transaction.getPdp(pdpIdLong);
        } catch (Exception e) {
            PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                    "Caught Exception trying to get pdp record with transaction.getPdp(" + pdpIdLong + ");");
            throw new PAPException("Could not get local pdp " + pdpIdLong);
        }
        if (pdpRecord == null) {
            throw new PersistenceException("The pdpRecord returned is null");
        }
        OnapPDP localPdp = null;
        try {
            localPdp = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getPDP(pdpRecord.getPdpId());
        } catch (PAPException e) {
            logger.warn("Caught PAPException trying to get local pdp  with papEngine.getPDP(" + pdpId + ");", e);
        }
        if (localPdp != null && pdpRecord.isDeleted()) {
            try {
                PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().removePDP(localPdp);
            } catch (PAPException e) {
                PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                        "Caught PAPException trying to get remove pdp with papEngine.removePDP(" + localPdp + ");");
                throw new PAPException("Could not remove pdp " + pdpId);
            }
        } else if (localPdp == null) {
            // add new pdp
            // get group
            OnapPDPGroup localGroup = null;
            try {
                localGroup =
                        PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getGroup(pdpRecord.getGroup().getGroupId());
            } catch (PAPException e1) {
                PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, PolicyDBDao.POLICYDBDAO_VAR,
                        "Caught PAPException trying to get local group to add pdp to with papEngine.getGroup(pdpRecord.getGroup().getGroupId());");
                throw new PAPException("Could not get local group");
            }
            try {
                PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().newPDP(pdpRecord.getPdpId(), localGroup,
                        pdpRecord.getPdpName(), pdpRecord.getDescription(), pdpRecord.getJmxPort());
            } catch (NullPointerException | PAPException e) {
                PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                        "Caught PAPException trying to create pdp with papEngine.newPDP(" + pdpRecord.getPdpId() + ", "
                                + localGroup + ", " + pdpRecord.getPdpName() + ", " + pdpRecord.getDescription() + ", "
                                + pdpRecord.getJmxPort() + ");");
                throw new PAPException("Could not create pdp " + pdpRecord);
            }
        } else {
            boolean needToUpdate = false;
            if (!PolicyDBDao.stringEquals(localPdp.getId(), pdpRecord.getPdpId())
                    || !PolicyDBDao.stringEquals(localPdp.getName(), pdpRecord.getPdpName())) {
                // again, we don't want to change the id, the papEngine will do
                // this
                localPdp.setName(pdpRecord.getPdpName());
                needToUpdate = true;
            }
            if (!PolicyDBDao.stringEquals(localPdp.getDescription(), pdpRecord.getDescription())) {
                localPdp.setDescription(pdpRecord.getDescription());
                needToUpdate = true;
            }
            String localPdpGroupId = null;
            try {
                localPdpGroupId = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getPDPGroup(localPdp).getId();
            } catch (PAPException e) {
                // could be null or something, just warn at this point
                logger.warn(
                        "Caught PAPException trying to get id of local group that pdp is in with localPdpGroupId = papEngine.getPDPGroup(localPdp).getId();",
                        e);
            }
            if (!PolicyDBDao.stringEquals(localPdpGroupId, pdpRecord.getGroup().getGroupId())) {
                OnapPDPGroup newPdpGroup = null;
                try {
                    newPdpGroup = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine()
                            .getGroup(pdpRecord.getGroup().getGroupId());
                } catch (PAPException e) {
                    // ok, now we have an issue. Time to stop things
                    PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                            "Caught PAPException trying to get id of local group to move pdp to with papEngine.getGroup(pdpRecord.getGroup().getGroupId());");
                    throw new PAPException("Could not get local group");
                }
                try {
                    PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().movePDP(localPdp, newPdpGroup);
                } catch (PAPException e) {
                    PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                            "Caught PAPException trying to move pdp with papEngine.movePDP(localPdp, newPdpGroup);");
                    throw new PAPException("Could not move pdp " + localPdp);
                }
            }
            if (localPdp.getJmxPort() != pdpRecord.getJmxPort()) {
                localPdp.setJmxPort(pdpRecord.getJmxPort());
                needToUpdate = true;
            }
            if (needToUpdate) {
                try {
                    PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().updatePDP(localPdp);
                } catch (PAPException e) {
                    PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                            "Caught PAPException trying to update pdp with papEngine.updatePdp(" + localPdp + ");");
                    throw new PAPException("Could not update pdp " + localPdp);
                }
            }
        }
        // compare to local situation
        // call command to update
    }

    private void handleIncomingPolicyChange(String policyId) {
        String policyName = null;
        Session session = sessionfactory.openSession();
        Query getPolicyEntityQuery = session.getNamedQuery("PolicyEntity.FindById");
        getPolicyEntityQuery.setParameter("id", Long.valueOf(policyId));

        @SuppressWarnings("unchecked")
        List<PolicyEntity> policies = getPolicyEntityQuery.list();
        PolicyEntity policy = null;
        if (!policies.isEmpty()) {
            policy = policies.get(0);
        }
        String action = "unknown action";
        try {
            if (policy != null) {
                policyName = policy.getPolicyName();
                logger.info("Deleting old Policy Config File for " + policy.getPolicyName());
                action = "delete";
                Path subFile = null;

                if (policy.getConfigurationData() != null) {
                    subFile =
                            getPolicySubFile(policy.getConfigurationData().getConfigurationName(), PolicyDBDao.CONFIG);
                } else if (policy.getActionBodyEntity() != null) {
                    subFile = getPolicySubFile(policy.getActionBodyEntity().getActionBodyName(), PolicyDBDao.ACTION);
                }

                if (subFile != null) {
                    Files.deleteIfExists(subFile);
                }
                if (policy.getConfigurationData() != null) {
                    writePolicySubFile(policy, PolicyDBDao.CONFIG);
                } else if (policy.getActionBodyEntity() != null) {
                    writePolicySubFile(policy, action);
                }
            }
        } catch (IOException e1) {
            PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, PolicyDBDao.POLICYDBDAO_VAR,
                    "Error occurred while performing [" + action + "] of Policy File: " + policyName);
        } finally {
            session.close();
        }
    }

    private boolean writePolicySubFile(PolicyEntity policy, String policyType) {
        logger.info("writePolicySubFile with policyName[" + policy.getPolicyName() + "] and policyType[" + policyType
                + "]");
        String type = null;
        String subTypeName = null;
        String subTypeBody = null;
        if (PolicyDBDao.CONFIG.equalsIgnoreCase(policyType)) {
            type = PolicyDBDao.CONFIG;
            subTypeName = FilenameUtils.removeExtension(policy.getConfigurationData().getConfigurationName());
            subTypeBody = policy.getConfigurationData().getConfigBody();

            String configType = policy.getConfigurationData().getConfigType();

            if (configType != null) {
                if (configType.equals(JSON_CONFIG)) {
                    subTypeName = subTypeName + ".json";
                }
                if (configType.equals(XML_CONFIG)) {
                    subTypeName = subTypeName + ".xml";
                }
                if (configType.equals(PROPERTIES_CONFIG)) {
                    subTypeName = subTypeName + ".properties";
                }
                if (configType.equals(OTHER_CONFIG)) {
                    subTypeName = subTypeName + ".txt";
                }
            }
        } else if (PolicyDBDao.ACTION.equalsIgnoreCase(policyType)) {
            type = PolicyDBDao.ACTION;
            subTypeName = policy.getActionBodyEntity().getActionBodyName();
            subTypeBody = policy.getActionBodyEntity().getActionBody();
        }
        Path filePath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS).toString(), type);

        if (subTypeBody == null) {
            subTypeBody = "";
        }
        boolean success = false;
        try {
            Files.deleteIfExists(Paths.get(filePath.toString(), subTypeName));
            File file = Paths.get(filePath.toString(), subTypeName).toFile();
            boolean value = file.createNewFile();
            logger.debug("New file created successfully" + value);
            try (FileWriter fileWriter = new FileWriter(file, false)) {
                // false to overwrite
                fileWriter.write(subTypeBody);
                fileWriter.close();
                success = true;
            }
        } catch (Exception e) {
            PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
                    "Exception occured while creating Configuration File for Policy : " + policy.getPolicyName());
        }
        return success;
    }

    Path getPolicySubFile(String inputFileName, String subFileType) {
        String filename = inputFileName;
        logger.info("getPolicySubFile(" + filename + ", " + subFileType + ")");
        Path filePath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS), subFileType);
        File file = null;

        filename = FilenameUtils.removeExtension(filename);

        for (File tmpFile : filePath.toFile().listFiles()) {
            if (FilenameUtils.removeExtension(tmpFile.getName()).equals(filename)) {
                file = tmpFile;
            }
        }

        Path finalPath = null;
        if (file != null) {
            finalPath = Paths.get(file.getAbsolutePath());
        }

        logger.info("end of getPolicySubFile: " + finalPath);
        return finalPath;
    }
}