aboutsummaryrefslogtreecommitdiffstats
path: root/ECOMP-PAP-REST/src/main/java/org/openecomp/policy/pap/xacml/rest/components/ActionPolicy.java
diff options
context:
space:
mode:
Diffstat (limited to 'ECOMP-PAP-REST/src/main/java/org/openecomp/policy/pap/xacml/rest/components/ActionPolicy.java')
-rw-r--r--ECOMP-PAP-REST/src/main/java/org/openecomp/policy/pap/xacml/rest/components/ActionPolicy.java626
1 files changed, 626 insertions, 0 deletions
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<String> dynamicLabelRuleAlgorithms = new LinkedList<String>();
+ List<String> dynamicFieldFunctionRuleAlgorithms = new LinkedList<String>();
+ List<String> dynamicFieldOneRuleAlgorithms = new LinkedList<String>();
+ List<String> dynamicFieldTwoRuleAlgorithms = new LinkedList<String>();
+
+ protected Map<String, String> dropDownMap = new HashMap<String, String>();
+
+ public ActionPolicy() {
+ super();
+ }
+
+ public ActionPolicy(PolicyRestAdapter policyAdapter){
+ this.policyAdapter = policyAdapter;
+ }
+
+ @Override
+ public Map<String, String> savePolicies() throws Exception {
+
+ Map<String, String> successMap = new HashMap<String,String>();
+ 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<String, String> 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<String,String> createDropDownMap(){
+ JPAUtils jpaUtils = null;
+ try {
+ jpaUtils = JPAUtils.getJPAUtilsInstance(policyAdapter.getEntityManagerFactory());
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ Map<Datatype, List<FunctionDefinition>> functionMap = jpaUtils.getFunctionDatatypeMap();
+ Map<String, String> dropDownMap = new HashMap<String, String>();
+ for (Datatype id : functionMap.keySet()) {
+ List<FunctionDefinition> functionDefinitions = (List<FunctionDefinition>) 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();
+ }
+
+
+
+}