From 91d04c64771832a0b8815ffbe1f0f9920320d94d Mon Sep 17 00:00:00 2001 From: Pamela Dragosh Date: Tue, 14 Feb 2017 19:41:00 -0500 Subject: Initial OpenECOMP policy/engine commit Change-Id: I7dbff37733b661643dd4d1caefa3d7dccc361b6e Signed-off-by: Pamela Dragosh --- .../pap/xacml/rest/components/ActionPolicy.java | 626 +++++++++++++++++++++ 1 file changed, 626 insertions(+) create mode 100644 ECOMP-PAP-REST/src/main/java/org/openecomp/policy/pap/xacml/rest/components/ActionPolicy.java (limited to 'ECOMP-PAP-REST/src/main/java/org/openecomp/policy/pap/xacml/rest/components/ActionPolicy.java') diff --git a/ECOMP-PAP-REST/src/main/java/org/openecomp/policy/pap/xacml/rest/components/ActionPolicy.java b/ECOMP-PAP-REST/src/main/java/org/openecomp/policy/pap/xacml/rest/components/ActionPolicy.java new file mode 100644 index 000000000..b6e003c91 --- /dev/null +++ b/ECOMP-PAP-REST/src/main/java/org/openecomp/policy/pap/xacml/rest/components/ActionPolicy.java @@ -0,0 +1,626 @@ +/*- + * ============LICENSE_START======================================================= + * ECOMP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 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.openecomp.policy.pap.xacml.rest.components; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Arrays; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.Query; + +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AnyOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ApplyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeAssignmentExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ConditionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.EffectType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.MatchType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObjectFactory; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObligationExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObligationExpressionsType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.RuleType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType; + +import org.apache.commons.io.FilenameUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.openecomp.policy.pap.xacml.rest.adapters.PolicyRestAdapter; +import org.openecomp.policy.pap.xacml.rest.util.JPAUtils; +import org.openecomp.policy.rest.jpa.ActionPolicyDict; +import org.openecomp.policy.rest.jpa.Datatype; +import org.openecomp.policy.rest.jpa.FunctionDefinition; + +import org.openecomp.policy.xacml.api.XACMLErrorConstants; + +import org.openecomp.policy.common.logging.eelf.MessageCodes; +import org.openecomp.policy.common.logging.eelf.PolicyLogger; +import org.openecomp.policy.common.logging.flexlogger.FlexLogger; +import org.openecomp.policy.common.logging.flexlogger.Logger; + +public class ActionPolicy extends Policy { + + /** + * Config Fields + */ + private static final Logger logger = FlexLogger.getLogger(ConfigPolicy.class); + + 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 PDP_ACTION = "PDP"; + public static final String PEP_ACTION = "PEP"; + public static final String TYPE_ACTION = "REST"; + + public static final String GET_METHOD = "GET"; + public static final String PUT_METHOD = "PUT"; + public static final String POST_METHOD = "POST"; + + public static final String PERFORMER_ATTRIBUTEID = "performer"; + public static final String TYPE_ATTRIBUTEID = "type"; + public static final String METHOD_ATTRIBUTEID = "method"; + public static final String HEADERS_ATTRIBUTEID = "headers"; + public static final String URL_ATTRIBUTEID = "url"; + public static final String BODY_ATTRIBUTEID = "body"; + + List dynamicLabelRuleAlgorithms = new LinkedList(); + List dynamicFieldFunctionRuleAlgorithms = new LinkedList(); + List dynamicFieldOneRuleAlgorithms = new LinkedList(); + List dynamicFieldTwoRuleAlgorithms = new LinkedList(); + + protected Map dropDownMap = new HashMap(); + + public ActionPolicy() { + super(); + } + + public ActionPolicy(PolicyRestAdapter policyAdapter){ + this.policyAdapter = policyAdapter; + } + + @Override + public Map savePolicies() throws Exception { + + Map successMap = new HashMap(); + if(isPolicyExists()){ + successMap.put("EXISTS", "This Policy already exist on the PAP"); + return successMap; + } + + if(!isPreparedToSave()){ + //Prep and configure the policy for saving + prepareToSave(); + } + + // Until here we prepared the data and here calling the method to create xml. + Path newPolicyPath = null; + newPolicyPath = Paths.get(policyAdapter.getParentPath().toString(), policyName); + successMap = createPolicy(newPolicyPath,getCorrectPolicyDataObject() ); + if (successMap.containsKey("success")) { + Path finalPolicyPath = getFinalPolicyPath(); + policyAdapter.setFinalPolicyPath(finalPolicyPath.toString()); + } + return successMap; + } + + //This is the method for preparing the policy for saving. We have broken it out + //separately because the fully configured policy is used for multiple things + @Override + public boolean prepareToSave() throws Exception{ + + if(isPreparedToSave()){ + //we have already done this + return true; + } + + int version = 0; + String policyID = policyAdapter.getPolicyID(); + + if (policyAdapter.isEditPolicy()) { + version = policyAdapter.getHighestVersion() + 1; + } else { + version = 1; + } + + // Create the Instance for pojo, PolicyType object is used in marshalling. + if (policyAdapter.getPolicyType().equals("Action")) { + PolicyType policyConfig = new PolicyType(); + + policyConfig.setVersion(Integer.toString(version)); + policyConfig.setPolicyId(policyID); + policyConfig.setTarget(new TargetType()); + policyAdapter.setData(policyConfig); + } + + if (policyAdapter.getData() != null) { + + // Save off everything + // making ready all the required elements to generate the action policy xml. + // Get the uniqueness for policy name. + Path newFile = getNextFilename(Paths.get(policyAdapter.getParentPath().toString()), policyAdapter.getPolicyType(), policyAdapter.getPolicyName(), version); + if (newFile == null) { + //TODO:EELF Cleanup - Remove logger + //logger.error("Policy already Exists, cannot create the policy."); + PolicyLogger.error("Policy already Exists, cannot create the policy."); + setPolicyExists(true); + return false; + } + policyName = newFile.getFileName().toString(); + + // Action body is optional so checking value provided or not + //String actionBodyString = policyAdapter.getActionBody(); + String comboDictValue = policyAdapter.getActionAttribute(); + String actionBody = getActionPolicyDict(comboDictValue).getBody(); + if(!(actionBody==null || "".equals(actionBody))){ + saveActionBody(policyName, actionBody); + } + + // Make sure the filename ends with an extension + if (policyName.endsWith(".xml") == false) { + policyName = policyName + ".xml"; + } + + PolicyType actionPolicy = (PolicyType) policyAdapter.getData(); + + actionPolicy.setDescription(policyAdapter.getPolicyDescription()); + + actionPolicy.setRuleCombiningAlgId(policyAdapter.getRuleCombiningAlgId()); + + AllOfType allOf = new AllOfType(); + + Map dynamicFieldComponentAttributes = policyAdapter.getDynamicFieldConfigAttributes(); + + // If there is any dynamic field attributes create the matches here + for (String keyField : dynamicFieldComponentAttributes.keySet()) { + String key = keyField; + String value = dynamicFieldComponentAttributes.get(key); + MatchType dynamicMatch = createDynamicMatch(key, value); + allOf.getMatch().add(dynamicMatch); + } + + AnyOfType anyOf = new AnyOfType(); + anyOf.getAllOf().add(allOf); + + TargetType target = new TargetType(); + target.getAnyOf().add(anyOf); + + // Adding the target to the policy element + actionPolicy.setTarget(target); + + RuleType rule = new RuleType(); + rule.setRuleId(policyAdapter.getRuleID()); + + rule.setEffect(EffectType.PERMIT); + rule.setTarget(new TargetType()); + + dynamicLabelRuleAlgorithms = policyAdapter.getDynamicRuleAlgorithmLabels(); + dynamicFieldFunctionRuleAlgorithms = policyAdapter.getDynamicRuleAlgorithmCombo(); + dynamicFieldOneRuleAlgorithms = policyAdapter.getDynamicRuleAlgorithmField1(); + dynamicFieldTwoRuleAlgorithms = policyAdapter.getDynamicRuleAlgorithmField2(); + //dropDownMap = policyAdapter.getDropDownMap(); + dropDownMap = createDropDownMap(); + + // Rule attributes are optional and dynamic so check and add them to condition. + if (dynamicLabelRuleAlgorithms != null && dynamicLabelRuleAlgorithms.size() > 0) { + boolean isCompound = false; + ConditionType condition = new ConditionType(); + int index = dynamicFieldOneRuleAlgorithms.size() - 1; + + for (String labelAttr : dynamicLabelRuleAlgorithms) { + // if the rule algorithm as a label means it is a compound + if (dynamicFieldOneRuleAlgorithms.get(index).toString().equals(labelAttr)) { + ApplyType actionApply = new ApplyType(); + + String selectedFunction = (String) dynamicFieldFunctionRuleAlgorithms.get(index).toString(); + String value1 = (String) dynamicFieldOneRuleAlgorithms.get(index).toString(); + String value2 = dynamicFieldTwoRuleAlgorithms.get(index).toString(); + actionApply.setFunctionId(dropDownMap.get(selectedFunction)); + actionApply.getExpression().add(new ObjectFactory().createApply(getInnerActionApply(value1))); + actionApply.getExpression().add(new ObjectFactory().createApply(getInnerActionApply(value2))); + condition.setExpression(new ObjectFactory().createApply(actionApply)); + isCompound = true; + } + + } + // if rule algorithm not a compound + if (!isCompound) { + condition.setExpression(new ObjectFactory().createApply(getInnerActionApply(dynamicLabelRuleAlgorithms.get(index).toString()))); + } + rule.setCondition(condition); + } + // set the obligations to rule + rule.setObligationExpressions(getObligationExpressions()); + actionPolicy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().add(rule); + policyAdapter.setPolicyData(actionPolicy); + } else { + //TODO:EELF Cleanup - Remove logger + //logger.error(XACMLErrorConstants.ERROR_DATA_ISSUE + "Unsupported data object." + policyAdapter.getData().getClass().getCanonicalName()); + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + "Unsupported data object." + policyAdapter.getData().getClass().getCanonicalName()); + } + + setPreparedToSave(true); + return true; + } + + // Saving the json Configurations file if exists at server location for action policy. + private void saveActionBody(String policyName, String actionBodyData) { + int version = 0; + int highestVersion = 0; + String domain = getParentPathSubScopeDir(); + String path = domain.replace('\\', '.'); + String removeExtension = policyName.substring(0, policyName.indexOf(".xml")); + String removeVersion = removeExtension.substring(0, removeExtension.indexOf(".")); + if (policyAdapter.isEditPolicy()) { + highestVersion = policyAdapter.getHighestVersion(); + if(highestVersion != 0){ + version = highestVersion + 1; + } + } else { + version = 1; + } + if(path.contains("/")){ + path = domain.replace('/', '.'); + logger.info("print the path:" +path); + } + try { + + File file = new File(ACTION_HOME + File.separator + path + "." + removeVersion + "." + version + ".json"); + + if (logger.isDebugEnabled()) + logger.debug("The action body is at " + file.getAbsolutePath()); + + // if file doesn't exists, then create it + if (!file.exists()) { + file.createNewFile(); + } + File configHomeDir = new File(ACTION_HOME); + File[] listOfFiles = configHomeDir.listFiles(); + if (listOfFiles != null){ + for(File eachFile : listOfFiles){ + if(eachFile.isFile()){ + String fileNameWithoutExtension = FilenameUtils.removeExtension(eachFile.getName()); + String actionFileNameWithoutExtension = FilenameUtils.removeExtension(path + "." + policyName); + if (fileNameWithoutExtension.equals(actionFileNameWithoutExtension)){ + //delete the file + if (logger.isInfoEnabled()) + logger.info("Deleting action body is at " + eachFile.getAbsolutePath()); + eachFile.delete(); + } + } + } + } + FileWriter fw = new FileWriter(file.getAbsoluteFile()); + BufferedWriter bw = new BufferedWriter(fw); + bw.write(actionBodyData); + bw.close(); + + if (logger.isInfoEnabled()) { + logger.info("Action Body is succesfully saved at " + file.getAbsolutePath()); + } + } catch (IOException e) { + e.printStackTrace(); + } + + } + + // Data required for obligation part is setting here. + private ObligationExpressionsType getObligationExpressions() { + + // TODO: add code to get all these values from dictionary + ObligationExpressionsType obligations = new ObligationExpressionsType(); + + ObligationExpressionType obligation = new ObligationExpressionType(); + String comboDictValue = policyAdapter.getActionAttribute(); + obligation.setObligationId(comboDictValue); + obligation.setFulfillOn(EffectType.PERMIT); + + // Add Action Assignment: + AttributeAssignmentExpressionType assignment1 = new AttributeAssignmentExpressionType(); + assignment1.setAttributeId(PERFORMER_ATTRIBUTEID); + assignment1.setCategory(CATEGORY_RECIPIENT_SUBJECT); + + AttributeValueType actionNameAttributeValue = new AttributeValueType(); + actionNameAttributeValue.setDataType(STRING_DATATYPE); + actionNameAttributeValue.getContent().add(performer.get(policyAdapter.getActionPerformer())); + + assignment1.setExpression(new ObjectFactory().createAttributeValue(actionNameAttributeValue)); + obligation.getAttributeAssignmentExpression().add(assignment1); + + // Add Type Assignment: + AttributeAssignmentExpressionType assignmentType = new AttributeAssignmentExpressionType(); + assignmentType.setAttributeId(TYPE_ATTRIBUTEID); + assignmentType.setCategory(CATEGORY_RESOURCE); + + AttributeValueType typeAttributeValue = new AttributeValueType(); + typeAttributeValue.setDataType(STRING_DATATYPE); + String actionDictType = getActionPolicyDict(comboDictValue).getType(); + typeAttributeValue.getContent().add(actionDictType); + + assignmentType.setExpression(new ObjectFactory().createAttributeValue(typeAttributeValue)); + obligation.getAttributeAssignmentExpression().add(assignmentType); + + // Add Rest_URL Assignment: + AttributeAssignmentExpressionType assignmentURL = new AttributeAssignmentExpressionType(); + assignmentURL.setAttributeId(URL_ATTRIBUTEID); + assignmentURL.setCategory(CATEGORY_RESOURCE); + + AttributeValueType actionURLAttributeValue = new AttributeValueType(); + actionURLAttributeValue.setDataType(URI_DATATYPE); + String actionDictUrl = getActionPolicyDict(comboDictValue).getUrl(); + actionURLAttributeValue.getContent().add(actionDictUrl); + + assignmentURL.setExpression(new ObjectFactory().createAttributeValue(actionURLAttributeValue)); + obligation.getAttributeAssignmentExpression().add(assignmentURL); + + // Add Method Assignment: + AttributeAssignmentExpressionType assignmentMethod = new AttributeAssignmentExpressionType(); + assignmentMethod.setAttributeId(METHOD_ATTRIBUTEID); + assignmentMethod.setCategory(CATEGORY_RESOURCE); + + AttributeValueType methodAttributeValue = new AttributeValueType(); + methodAttributeValue.setDataType(STRING_DATATYPE); + String actionDictMethod = getActionPolicyDict(comboDictValue).getMethod(); + methodAttributeValue.getContent().add(actionDictMethod); + + assignmentMethod.setExpression(new ObjectFactory().createAttributeValue(methodAttributeValue)); + obligation.getAttributeAssignmentExpression().add(assignmentMethod); + + // Add JSON_URL Assignment: + String actionBody = getActionPolicyDict(comboDictValue).getBody(); + if (!actionBody.equals(null)) { + //if(!(actionBody==null || "".equals(actionBody))){ + AttributeAssignmentExpressionType assignmentJsonURL = new AttributeAssignmentExpressionType(); + assignmentJsonURL.setAttributeId(BODY_ATTRIBUTEID); + assignmentJsonURL.setCategory(CATEGORY_RESOURCE); + + AttributeValueType jsonURLAttributeValue = new AttributeValueType(); + jsonURLAttributeValue.setDataType(URI_DATATYPE); + final Path gitPath = Paths.get(policyAdapter.getUserGitPath().toString());; + String policyDir = policyAdapter.getParentPath().toString(); + int startIndex1 = policyDir.indexOf(gitPath.toString()) + gitPath.toString().length() + 1; + policyDir = policyDir.substring(startIndex1, policyDir.length()); + logger.info("print the main domain value"+policyDir); + String path = policyDir.replace('\\', '.'); + if(path.contains("/")){ + path = policyDir.replace('/', '.'); + logger.info("print the path:" +path); + } + jsonURLAttributeValue.getContent().add(CONFIG_URL + "/Action/" + path + "." +FilenameUtils.removeExtension(policyName) + ".json"); + + assignmentJsonURL.setExpression(new ObjectFactory().createAttributeValue(jsonURLAttributeValue)); + obligation.getAttributeAssignmentExpression().add(assignmentJsonURL); + } + + if(!getActionPolicyDict(comboDictValue).getHeader().equals(null)){ + String headerVal = getActionPolicyDict(comboDictValue).getHeader(); + if(headerVal != null && !headerVal.equals("")){ + // parse it on : to get number of headers + String[] result = headerVal.split(":"); + System.out.println(Arrays.toString(result)); + for (String eachString : result){ + // parse each value on = + String[] textFieldVals = eachString.split("="); + obligation.getAttributeAssignmentExpression().add(addDynamicHeaders(textFieldVals[0], textFieldVals[1])); + } + } + + } + + obligations.getObligationExpression().add(obligation); + return obligations; + } + + + // if compound setting the inner apply here + protected ApplyType getInnerActionApply(String value1Label) { + ApplyType actionApply = new ApplyType(); + int index = 0; + // check the index for the label. + for (String labelAttr : dynamicLabelRuleAlgorithms) { + if (labelAttr.equals(value1Label)) { + String value1 = dynamicFieldOneRuleAlgorithms.get(index).toString(); + // check if the row contains label again + for (String labelValue : dynamicLabelRuleAlgorithms) { + if (labelValue.equals(value1)) { + return getCompoundApply(index); + } + } + + // Getting the values from the form. + String functionKey = dynamicFieldFunctionRuleAlgorithms.get(index).toString(); + String value2 = dynamicFieldTwoRuleAlgorithms.get(index).toString(); + actionApply.setFunctionId(dropDownMap.get(functionKey)); + // if two text field are rule attributes. + if ((value1.contains(RULE_VARIABLE)) && (value2.contains(RULE_VARIABLE))) { + ApplyType innerActionApply1 = new ApplyType(); + ApplyType innerActionApply2 = new ApplyType(); + AttributeDesignatorType attributeDesignator1 = new AttributeDesignatorType(); + AttributeDesignatorType attributeDesignator2 = new AttributeDesignatorType(); + // If selected function is Integer function set integer functionID + if (functionKey.toLowerCase().contains("integer")) { + innerActionApply1.setFunctionId(FUNTION_INTEGER_ONE_AND_ONLY); + innerActionApply2.setFunctionId(FUNTION_INTEGER_ONE_AND_ONLY); + attributeDesignator1.setDataType(INTEGER_DATATYPE); + attributeDesignator2.setDataType(INTEGER_DATATYPE); + } else { + // If selected function is not a Integer function + // set String functionID + innerActionApply1.setFunctionId(FUNCTION_STRING_ONE_AND_ONLY); + innerActionApply2.setFunctionId(FUNCTION_STRING_ONE_AND_ONLY); + attributeDesignator1.setDataType(STRING_DATATYPE); + attributeDesignator2.setDataType(STRING_DATATYPE); + } + attributeDesignator1.setCategory(CATEGORY_RESOURCE); + attributeDesignator2.setCategory(CATEGORY_RESOURCE); + + // Here set actual field values + attributeDesignator1.setAttributeId(value1.contains("resource:") ? value1.substring(9): value1.substring(8)); + attributeDesignator2.setAttributeId(value1.contains("resource:") ? value1.substring(9): value1.substring(8)); + + innerActionApply1.getExpression().add(new ObjectFactory().createAttributeDesignator(attributeDesignator1)); + innerActionApply2.getExpression().add(new ObjectFactory().createAttributeDesignator(attributeDesignator2)); + + actionApply.getExpression().add(new ObjectFactory().createApply(innerActionApply1)); + actionApply.getExpression().add(new ObjectFactory().createApply(innerActionApply2)); + + } else {// if either of one text field is rule attribute. + ApplyType innerActionApply = new ApplyType(); + AttributeDesignatorType attributeDesignator = new AttributeDesignatorType(); + AttributeValueType actionConditionAttributeValue = new AttributeValueType(); + + if (functionKey.toLowerCase().contains("integer")) { + innerActionApply.setFunctionId(FUNTION_INTEGER_ONE_AND_ONLY); + actionConditionAttributeValue.setDataType(INTEGER_DATATYPE); + attributeDesignator.setDataType(INTEGER_DATATYPE); + } else { + innerActionApply.setFunctionId(FUNCTION_STRING_ONE_AND_ONLY); + actionConditionAttributeValue.setDataType(STRING_DATATYPE); + attributeDesignator.setDataType(STRING_DATATYPE); + } + + String attributeId = null; + String attributeValue = null; + + // Find which textField has rule attribute and set it as + attributeId = value1; + attributeValue = value2; + + if (attributeId != null) { + attributeDesignator.setCategory(CATEGORY_RESOURCE); + attributeDesignator.setAttributeId(attributeId); + } + actionConditionAttributeValue.getContent().add(attributeValue); + innerActionApply.getExpression().add(new ObjectFactory().createAttributeDesignator(attributeDesignator)); + // Decide the order of element based the values. + if (attributeId.equals(value1)) { + actionApply.getExpression().add(new ObjectFactory().createApply(innerActionApply)); + actionApply.getExpression().add(new ObjectFactory().createAttributeValue(actionConditionAttributeValue)); + } else { + actionApply.getExpression().add(new ObjectFactory().createAttributeValue(actionConditionAttributeValue)); + actionApply.getExpression().add(new ObjectFactory().createApply(innerActionApply)); + } + } + } + index++; + } + return actionApply; + } + + // if the rule algorithm is multiple compound one setting the apply + protected ApplyType getCompoundApply(int index) { + ApplyType actionApply = new ApplyType(); + String selectedFunction = dynamicFieldFunctionRuleAlgorithms.get(index).toString(); + String value1 = dynamicFieldOneRuleAlgorithms.get(index).toString(); + String value2 = dynamicFieldTwoRuleAlgorithms.get(index).toString(); + actionApply.setFunctionId(dropDownMap.get(selectedFunction)); + actionApply.getExpression().add(new ObjectFactory().createApply(getInnerActionApply(value1))); + actionApply.getExpression().add(new ObjectFactory().createApply(getInnerActionApply(value2))); + return actionApply; + } + + // Adding the dynamic headers if any + private AttributeAssignmentExpressionType addDynamicHeaders(String header, String value) { + AttributeAssignmentExpressionType assignmentHeaders = new AttributeAssignmentExpressionType(); + assignmentHeaders.setAttributeId("headers:" + header); + assignmentHeaders.setCategory(CATEGORY_RESOURCE); + + AttributeValueType headersAttributeValue = new AttributeValueType(); + headersAttributeValue.setDataType(STRING_DATATYPE); + headersAttributeValue.getContent().add(value); + + assignmentHeaders.setExpression(new ObjectFactory().createAttributeValue(headersAttributeValue)); + return assignmentHeaders; + } + + private Map createDropDownMap(){ + JPAUtils jpaUtils = null; + try { + jpaUtils = JPAUtils.getJPAUtilsInstance(policyAdapter.getEntityManagerFactory()); + } catch (Exception e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + Map> functionMap = jpaUtils.getFunctionDatatypeMap(); + Map dropDownMap = new HashMap(); + for (Datatype id : functionMap.keySet()) { + List functionDefinitions = (List) functionMap + .get(id); + for (FunctionDefinition functionDef : functionDefinitions) { + dropDownMap.put(functionDef.getShortname(),functionDef.getXacmlid()); + } + } + + return dropDownMap; + } + + private ActionPolicyDict getActionPolicyDict(String attributeName){ + ActionPolicyDict retObj = new ActionPolicyDict(); + //EntityManagerFactory emf = policyAdapter.getEntityManagerFactory(); + //EntityManager em = emf.createEntityManager(); + EntityManager em = policyAdapter.getEntityManagerFactory().createEntityManager(); + Query getActionPolicyDicts = em.createNamedQuery("ActionPolicyDict.findAll"); + List actionPolicyDicts = getActionPolicyDicts.getResultList(); + + for (Object id : actionPolicyDicts) { + //ActionPolicyDict actionPolicyList = actionPolicyDicts.getItem(id).getEntity(); + ActionPolicyDict actionPolicy = (ActionPolicyDict) id; + if(attributeName.equals(actionPolicy.getAttributeName())){ + retObj = actionPolicy; + break; + } + } + + try{ + em.getTransaction().commit(); + } catch(Exception e){ + try{ + em.getTransaction().rollback(); + } catch(Exception e2){ + e2.printStackTrace(); + } + } + em.close(); + + return retObj; + } + + @Override + public Object getCorrectPolicyDataObject() { + return policyAdapter.getPolicyData(); + } + + + +} -- cgit 1.2.3-korg