aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorJorge Hernandez <jh1730@att.com>2018-07-26 18:05:23 +0000
committerGerrit Code Review <gerrit@onap.org>2018-07-26 18:05:23 +0000
commitdd986507648898887715a20c2f962bc714e28882 (patch)
treed0f37c733f4e82dd868d7c44432157b60a98f773
parentd6838664316b9bfbc082f68889f4475cd25c81fa (diff)
parent89df27fc144d1c1a7f6beed0e0bd0038f38ec14e (diff)
Merge "Fix nested stmts issue of Sonar"
-rw-r--r--BRMSGateway/src/main/java/org/onap/policy/brms/api/BrmsPush.java4
-rw-r--r--ONAP-REST/src/main/java/org/onap/policy/rest/util/MSModelUtils.java2668
2 files changed, 1336 insertions, 1336 deletions
diff --git a/BRMSGateway/src/main/java/org/onap/policy/brms/api/BrmsPush.java b/BRMSGateway/src/main/java/org/onap/policy/brms/api/BrmsPush.java
index b8706bb9b..507e17fea 100644
--- a/BRMSGateway/src/main/java/org/onap/policy/brms/api/BrmsPush.java
+++ b/BRMSGateway/src/main/java/org/onap/policy/brms/api/BrmsPush.java
@@ -787,9 +787,7 @@ public class BrmsPush {
LOGGER.error("Error while starting Transaction " + e);
}
if (!modifiedGroups.isEmpty()) {
- Boolean flag;
- flag = buildAndGenerateJarFile();
- if (flag) {
+ if (buildAndGenerateJarFile()) {
sendNotification(controllers);
}
}
diff --git a/ONAP-REST/src/main/java/org/onap/policy/rest/util/MSModelUtils.java b/ONAP-REST/src/main/java/org/onap/policy/rest/util/MSModelUtils.java
index 1f40be60a..50628d7d5 100644
--- a/ONAP-REST/src/main/java/org/onap/policy/rest/util/MSModelUtils.java
+++ b/ONAP-REST/src/main/java/org/onap/policy/rest/util/MSModelUtils.java
@@ -3,6 +3,7 @@
* ONAP-REST
* ================================================================================
* Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Modified Copyright (C) 2018 Samsung Electronics Co., Ltd.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -20,41 +21,13 @@
package org.onap.policy.rest.util;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import java.util.Map.Entry;
-
+import com.att.research.xacml.util.XACMLProperties;
+import com.google.gson.Gson;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.common.util.EMap;
-import org.eclipse.emf.common.util.Enumerator;
-import org.eclipse.emf.common.util.TreeIterator;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.EAnnotation;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EEnum;
-import org.eclipse.emf.ecore.EEnumLiteral;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.common.util.*;
+import org.eclipse.emf.ecore.*;
import org.eclipse.emf.ecore.impl.EAttributeImpl;
import org.eclipse.emf.ecore.impl.EEnumImpl;
import org.eclipse.emf.ecore.resource.Resource;
@@ -65,1320 +38,1349 @@ import org.json.JSONObject;
import org.onap.policy.rest.XACMLRestProperties;
import org.yaml.snakeyaml.Yaml;
-import com.att.research.xacml.util.XACMLProperties;
-import com.google.gson.Gson;
+import java.io.*;
+import java.util.*;
+import java.util.Map.Entry;
public class MSModelUtils {
- private static final Log logger = LogFactory.getLog(MSModelUtils.class);
-
- private HashMap<String,MSAttributeObject > classMap = new HashMap<>();
- private HashMap<String, String> enumMap = new HashMap<>();
- private HashMap<String, String> matchingClass = new HashMap<>();
- private String configuration = "configuration";
- private String dictionary = "dictionary";
- private String onap = "";
- private String policy = "";
- private String eProxyURI = "eProxyURI:";
- private List<String> orderedElements = new ArrayList<>();
- private String dataOrderInfo = null;
- private Set<String> uniqueDataKeys= new HashSet<>();
- private Set<String> uniqueKeys= new HashSet<>();
- private String listConstraints = null;
- private String referenceAttributes;
- private LinkedHashMap<String, Object> retmap = new LinkedHashMap<>();
- private Map<String, String> matchableValues;
- public static final String PROPERTIES=".properties.";
- public static final String DATATYPE = "data_types.policy.data.";
- public static final String TYPE=".type";
- public static final String REQUIRED=".required";
- public static final String MATCHABLE=".matchable";
- public static final String STRING="string";
- public static final String INTEGER="integer";
- public static final String LIST="list";
- public static final String MAP="map";
- public static final String DEFAULT=".default";
- public static final String MANYFALSE=":MANY-false";
- public static final String MANYTRUE=":MANY-true";
- public static final String DEFAULTVALUE=":defaultValue-";
- public static final String REQUIREDVALUE=":required-";
- public static final String MATCHABLEKEY="matchable";
- public static final String REQUIREDFALSE=":required-false";
- public static final String REQUIREDTRUE=":required-true";
- public static final String MATCHINGTRUE="matching-true";
-
- private StringBuilder dataListBuffer=new StringBuilder();
- private List<String> dataConstraints= new ArrayList <>();
- private String attributeString = null;
-
- public MSModelUtils(){
- }
-
- public MSModelUtils(String onap, String policy){
- this.onap = onap;
- this.policy = policy;
- }
-
- private enum ANNOTATION_TYPE{
- MATCHING, VALIDATION, DICTIONARY
- };
-
- public enum MODEL_TYPE {
- XMI
- };
-
-
- public Map<String, MSAttributeObject> processEpackage(String file, MODEL_TYPE model){
- if (model == MODEL_TYPE.XMI ){
- processXMIEpackage(file);
- }
- return classMap;
-
- }
-
- private void processXMIEpackage(String xmiFile){
- EPackage root = getEpackage(xmiFile);
- TreeIterator<EObject> treeItr = root.eAllContents();
- String className;
- String returnValue;
-
- // Pulling out dependency from file
- while (treeItr.hasNext()) {
- EObject obj = treeItr.next();
- if (obj instanceof EClassifier) {
- EClassifier eClassifier = (EClassifier) obj;
- className = eClassifier.getName();
-
- if (obj instanceof EEnum) {
- enumMap.putAll(getEEnum(obj));
- }else if (obj instanceof EClass) {
- String temp = getDependencyList(eClassifier).toString();
- returnValue = StringUtils.replaceEach(temp, new String[]{"[", "]"}, new String[]{"", ""});
- getAttributes(className, returnValue, root);
- }
- }
- }
-
- if (!enumMap.isEmpty()){
- addEnumClassMap();
- }
- if (!matchingClass.isEmpty()){
- CheckForMatchingClass();
- }
- }
-
- private void CheckForMatchingClass() {
- HashMap<String, String> tempAttribute = new HashMap<>();
-
- for (Entry<String, String> set : matchingClass.entrySet()){
- String key = set.getKey();
- if (classMap.containsKey(key)){
- Map<String, String> listAttributes = classMap.get(key).getAttribute();
- Map<String, String> listRef = classMap.get(key).getRefAttribute();
- for ( Entry<String, String> eSet : listAttributes.entrySet()){
- String key2 = eSet.getKey();
- tempAttribute.put(key2, MATCHINGTRUE);
- }
- for ( Entry<String, String> eSet : listRef.entrySet()){
- String key3 = eSet.getKey();
- tempAttribute.put(key3, MATCHINGTRUE);
- }
-
- }
- UpdateMatching(tempAttribute, key);
- }
-
- }
-
-
-
- private void UpdateMatching(HashMap<String, String> tempAttribute, String key) {
- Map<String, MSAttributeObject> newClass = classMap;
-
- for (Entry<String, MSAttributeObject> updateClass : newClass.entrySet()){
- Map<String, String> valueMap = updateClass.getValue().getMatchingSet();
- String keymap = updateClass.getKey();
- if (valueMap.containsKey(key)){
- Map<String, String> modifyMap = classMap.get(keymap).getMatchingSet();
- modifyMap.remove(key);
- modifyMap.putAll(tempAttribute);
- classMap.get(keymap).setMatchingSet(modifyMap);
- }
-
- }
- }
-
- private void addEnumClassMap() {
- for (Entry<String, MSAttributeObject> value :classMap.entrySet()){
- value.getValue().setEnumType(enumMap);
- }
- }
-
- private EPackage getEpackage(String xmiFile) {
- ResourceSet resSet = new ResourceSetImpl();
- Resource.Factory.Registry reg = Resource.Factory.Registry.INSTANCE;
- Map<String, Object> m = reg.getExtensionToFactoryMap();
- m.put("xmi", new XMIResourceFactoryImpl());
- Resource resource = resSet.getResource(URI.createFileURI(xmiFile), true);
- try {
- resource.load(Collections.emptyMap());
- } catch (IOException e) {
- logger.error("Error loading Encore Resource for new Model" + e);
- }
-
- return (EPackage) resource.getContents().get(0);
- }
-
- private HashMap<String, String> getEEnum(EObject obj) {
- List<String> valueList = new ArrayList<>();
- HashMap<String, String> returnMap = new HashMap<>();
- EEnum eenum = (EEnum)obj;
-
- String name = eenum.getName();
- for (EEnumLiteral eEnumLiteral : eenum.getELiterals())
- {
- Enumerator instance = eEnumLiteral.getInstance();
- String value = instance.getLiteral();
- valueList.add(value);
- }
- returnMap.put(name, valueList.toString());
- return returnMap;
- }
-
- public void getAttributes(String className, String dependency, EPackage root) {
- List<String> dpendList = new ArrayList<>();
- if (dependency!=null){
- dpendList = new ArrayList<>(Arrays.asList(dependency.split(",")));
- }
- MSAttributeObject msAttributeObject = new MSAttributeObject();
- msAttributeObject.setClassName(className);
- String extendClass = getSubTypes(root, className);
- Map<String, String> returnRefList = getRefAttributeList(root, className, extendClass);
- Map<String, String> returnAttributeList = getAttributeList(root, className, extendClass);
- Map<String, Object> returnSubList = getSubAttributeList(root, className, extendClass);
- HashMap<String, String> returnAnnotation = getAnnotation(root, className, extendClass);
- msAttributeObject.setAttribute(returnAttributeList);
- msAttributeObject.setRefAttribute(returnRefList);
- msAttributeObject.setSubClass(returnSubList);
- msAttributeObject.setDependency(dpendList.toString());
- msAttributeObject.addMatchingSet(returnAnnotation);
- msAttributeObject.setPolicyTempalate(isPolicyTemplate(root, className));
-
- this.classMap.put(className, msAttributeObject);
- }
-
- private HashMap<String, String> getAnnotation(EPackage root, String className, String extendClass) {
- TreeIterator<EObject> treeItr = root.eAllContents();
- boolean requiredAttribute = false;
- boolean requiredMatchAttribute = false;
- HashMap<String, String> annotationSet = new HashMap<>();
- String matching;
- String range;
- String annotationDict;
-
- // Pulling out dependency from file
- while (treeItr.hasNext()) {
- EObject obj = treeItr.next();
- if (obj instanceof EClassifier) {
- requiredAttribute = isRequiredAttribute(obj, className );
- requiredMatchAttribute = isRequiredAttribute(obj, extendClass );
- }
-
- if (requiredAttribute){
- if (obj instanceof EStructuralFeature) {
- EStructuralFeature eStrucClassifier = (EStructuralFeature) obj;
- if (!eStrucClassifier.getEAnnotations().isEmpty()) {
- matching = annotationValue(eStrucClassifier, ANNOTATION_TYPE.MATCHING, policy);
- if (matching!=null){
- annotationSet.put(eStrucClassifier.getName(), matching);
- }
- range = annotationValue(eStrucClassifier, ANNOTATION_TYPE.VALIDATION, policy);
- if (range!=null){
- annotationSet.put(eStrucClassifier.getName(), range);
- }
- annotationDict = annotationValue(eStrucClassifier, ANNOTATION_TYPE.DICTIONARY, policy);
- if (annotationDict!=null){
- annotationSet.put(eStrucClassifier.getName(), annotationDict);
- }
- }
- }
- } else if (requiredMatchAttribute && (obj instanceof EStructuralFeature)) {
- EStructuralFeature eStrucClassifier = (EStructuralFeature) obj;
- if (!eStrucClassifier.getEAnnotations().isEmpty()) {
- matching = annotationValue(eStrucClassifier, ANNOTATION_TYPE.MATCHING, policy);
- if (matching!=null){
- if (obj instanceof EReference){
- EClass refType = ((EReference) obj).getEReferenceType();
- annotationSet.put(refType.getName(), matching);
- matchingClass.put(refType.getName(), matching);
- }else{
- annotationSet.put(eStrucClassifier.getName(), matching);
- }
- }
- }
- }
- }
- return annotationSet;
- }
-
- private Map<String, Object> getSubAttributeList(EPackage root, String className , String superClass) {
- TreeIterator<EObject> treeItr = root.eAllContents();
- boolean requiredAttribute = false;
- Map<String, Object> subAttribute = new HashMap<>();
- int rollingCount = 0;
- int processClass = 0;
- boolean annotation;
-
- // Pulling out dependency from file
- while (treeItr.hasNext() && rollingCount < 2) {
-
- EObject obj = treeItr.next();
- if (obj instanceof EClassifier) {
- if (isRequiredAttribute(obj, className ) || isRequiredAttribute(obj, superClass )){
- requiredAttribute = true;
- }else {
- requiredAttribute = false;
- }
- if (requiredAttribute){
- processClass++;
- }
- rollingCount = rollingCount+processClass;
- }
-
- if (requiredAttribute && (obj instanceof EStructuralFeature)) {
- EStructuralFeature eStrucClassifier = (EStructuralFeature) obj;
- if (!eStrucClassifier.getEAnnotations().isEmpty()) {
- annotation = annotationTest(eStrucClassifier, configuration, onap);
- if (annotation && obj instanceof EReference) {
- EClass refType = ((EReference) obj).getEReferenceType();
- if(!refType.toString().contains(eProxyURI)){
- String required = REQUIREDFALSE;
- if(eStrucClassifier.getLowerBound() == 1){
- required = REQUIREDTRUE;
- }
- subAttribute.put(eStrucClassifier.getName(), refType.getName() + required);
- }
- }
- }
- }
- }
- return subAttribute;
- }
-
- public String checkDefultValue(String defultValue) {
- if (defultValue!=null){
- return DEFAULTVALUE+ defultValue;
- }
- return ":defaultValue-NA";
-
- }
-
- public String checkRequiredPattern(int upper, int lower) {
-
- String pattern = XACMLProperties.getProperty(XACMLRestProperties.PROP_XCORE_REQUIRED_PATTERN);
-
- if (pattern!=null){
- if (upper == Integer.parseInt(pattern.split(",")[1]) && lower==Integer.parseInt(pattern.split(",")[0])){
- return REQUIREDTRUE;
- }
- }
-
- return REQUIREDFALSE;
- }
-
- public JSONObject buildJavaObject(Map<String, String> map){
-
- return new JSONObject(map);
- }
-
- public Map<String, String> getRefAttributeList(EPackage root, String className, String superClass){
-
- TreeIterator<EObject> treeItr = root.eAllContents();
- boolean requiredAttribute = false;
- HashMap<String, String> refAttribute = new HashMap<>();
- int rollingCount = 0;
- int processClass = 0;
- boolean annotation;
- // Pulling out dependency from file
- while (treeItr.hasNext()) {
- EObject obj = treeItr.next();
- if (obj instanceof EClassifier) {
- if (isRequiredAttribute(obj, className ) || isRequiredAttribute(obj, superClass )){
- requiredAttribute = true;
- }else {
- requiredAttribute = false;
- }
- if (requiredAttribute){
- processClass++;
- }
- rollingCount = rollingCount+processClass;
- }
-
- if (requiredAttribute && (obj instanceof EStructuralFeature)) {
- EStructuralFeature eStrucClassifier = (EStructuralFeature) obj;
- if (!eStrucClassifier.getEAnnotations().isEmpty()) {
- annotation = annotationTest(eStrucClassifier, configuration, onap);
- if ( annotation && obj instanceof EReference) {
- EClass refType = ((EReference) obj).getEReferenceType();
- if(refType.toString().contains(eProxyURI)){
- String one = refType.toString().split(eProxyURI)[1];
- String refValue = StringUtils.replaceEach(one.split("#")[1], new String[]{"//", ")"}, new String[]{"", ""});
- refAttribute.put(eStrucClassifier.getName(), refValue);
- } else {
- String array = arrayCheck(((EStructuralFeature) obj).getUpperBound());
- String required = REQUIREDFALSE;
- if(((EStructuralFeature) obj).getLowerBound() == 1){
- required = REQUIREDTRUE;
- }
- refAttribute.put(eStrucClassifier.getName(), refType.getName() + array + required);
- }
- } else if (annotation && obj instanceof EAttributeImpl){
- EClassifier refType = ((EAttributeImpl) obj).getEType();
- if (refType instanceof EEnumImpl){
- String array = arrayCheck(((EStructuralFeature) obj).getUpperBound());
- String required = REQUIREDFALSE;
- if(((EStructuralFeature) obj).getLowerBound() == 1){
- required = REQUIREDTRUE;
- }
- refAttribute.put(eStrucClassifier.getName(), refType.getName() + array + required);
- }
- }
- }
- }
- }
-
- return refAttribute;
- }
-
- private boolean annotationTest(EStructuralFeature eStrucClassifier, String annotation, String type) {
- String annotationType;
- EAnnotation eAnnotation;
- String onapType;
- String onapValue;
-
- EList<EAnnotation> value = eStrucClassifier.getEAnnotations();
-
- for (int i = 0; i < value.size(); i++){
- annotationType = value.get(i).getSource();
- eAnnotation = eStrucClassifier.getEAnnotations().get(i);
- onapType = eAnnotation.getDetails().get(0).getValue();
- onapValue = eAnnotation.getDetails().get(0).getKey();
-
- if (annotationType.contains(type) && onapType.contains(annotation)){
- return true;
- }
-
- if (annotationType.contains(type) && onapValue.contains(annotation)){
- return true;
- }
- }
-
- return false;
- }
-
-
- private String annotationValue(EStructuralFeature eStrucClassifier, ANNOTATION_TYPE annotation, String type) {
- String annotationType;
- EAnnotation eAnnotation;
- String onapType;
- String onapValue = null;
-
- EList<EAnnotation> value = eStrucClassifier.getEAnnotations();
-
- for (int i = 0; i < value.size(); i++){
- annotationType = value.get(i).getSource();
- eAnnotation = eStrucClassifier.getEAnnotations().get(i);
- onapType = eAnnotation.getDetails().get(0).getKey();
- if (annotationType.contains(type) && onapType.compareToIgnoreCase(annotation.toString())==0){
- onapValue = eAnnotation.getDetails().get(0).getValue();
- if (annotation == ANNOTATION_TYPE.VALIDATION){
- return onapValue;
- } else {
- return onapType + "-" + onapValue;
- }
- }
- }
-
- return onapValue;
- }
- public boolean isRequiredAttribute(EObject obj, String className){
- EClassifier eClassifier = (EClassifier) obj;
- String workingClass = eClassifier.getName().trim();
- if (workingClass.equalsIgnoreCase(className)){
- return true;
- }
-
- return false;
- }
-
- private boolean isPolicyTemplate(EPackage root, String className){
-
- for (EClassifier classifier : root.getEClassifiers()){
- if (classifier instanceof EClass) {
- EClass eClass = (EClass)classifier;
- if (eClass.getName().contentEquals(className)){
- EList<EAnnotation> value = eClass.getEAnnotations();
- for (EAnnotation workingValue : value){
- EMap<String, String> keyMap = workingValue.getDetails();
- if (keyMap.containsKey("policyTemplate")){
- return true;
- }
- }
- }
- }
- }
- return false;
- }
- private String getSubTypes(EPackage root, String className) {
- String returnSubTypes = null;
- for (EClassifier classifier : root.getEClassifiers()){
- if (classifier instanceof EClass) {
- EClass eClass = (EClass)classifier;
-
- for (EClass eSuperType : eClass.getEAllSuperTypes())
- {
- if (eClass.getName().contentEquals(className)){
- returnSubTypes = eSuperType.getName();
- }
- }
- }
- }
- return returnSubTypes;
- }
-
- public Map<String, String> getAttributeList(EPackage root, String className, String superClass){
-
- TreeIterator<EObject> treeItr = root.eAllContents();
- boolean requiredAttribute = false;
- HashMap<String, String> refAttribute = new HashMap<>();
- boolean annotation;
- boolean dictionaryTest;
- String defaultValue;
- String eType;
-
- // Pulling out dependency from file
- while (treeItr.hasNext()) {
- EObject obj = treeItr.next();
- if (obj instanceof EClassifier) {
- if (isRequiredAttribute(obj, className ) || isRequiredAttribute(obj, superClass )){
- requiredAttribute = true;
- }else {
- requiredAttribute = false;
- }
-
- }
-
- if (requiredAttribute && (obj instanceof EStructuralFeature)) {
- EStructuralFeature eStrucClassifier = (EStructuralFeature) obj;
- if (!eStrucClassifier.getEAnnotations().isEmpty()) {
- annotation = annotationTest(eStrucClassifier, configuration, onap);
- dictionaryTest = annotationTest(eStrucClassifier, dictionary, policy);
- EClassifier refType = ((EStructuralFeature) obj).getEType();
- if (annotation && !(obj instanceof EReference) && !(refType instanceof EEnumImpl)) {
- String name = eStrucClassifier.getName();
- if (dictionaryTest){
- eType = annotationValue(eStrucClassifier, ANNOTATION_TYPE.DICTIONARY, policy);
- }else {
- eType = eStrucClassifier.getEType().getInstanceClassName();
- }
- defaultValue = checkDefultValue(((EStructuralFeature) obj).getDefaultValueLiteral());
-
- String array = arrayCheck(((EStructuralFeature) obj).getUpperBound());
- String required = checkRequiredPattern(((EStructuralFeature) obj).getUpperBound(), ((EStructuralFeature) obj).getLowerBound());
- String attributeValue = eType + defaultValue + required + array;
- refAttribute.put(name, attributeValue);
- }
- }
- }
- }
- return refAttribute;
-
- }
-
- public String arrayCheck(int upperBound) {
-
- if (upperBound == -1){
- return MANYTRUE;
- }
-
- return MANYFALSE;
- }
-
- public List<String> getDependencyList(EClassifier eClassifier){
- List<String> returnValue = new ArrayList<>();;
- EList<EClass> somelist = ((EClass) eClassifier).getEAllSuperTypes();
- if (somelist.isEmpty()){
- return returnValue;
- }
- for(EClass depend: somelist){
- if (depend.toString().contains(eProxyURI)){
- String one = depend.toString().split(eProxyURI)[1];
- String value = StringUtils.replaceEach(one.split("#")[1], new String[]{"//", ")"}, new String[]{"", ""});
- returnValue.add(value);
- }
- }
-
- return returnValue;
- }
-
- public Map<String, String> buildSubList(Map<String, String> subClassAttributes, Map<String, MSAttributeObject> classMap, String className){
- Map<String, String> missingValues = new HashMap<>();
- Map<String, String> workingMap;
- boolean enumType;
-
- for ( Entry<String, String> map : classMap.get(className).getRefAttribute().entrySet()){
- String value = map.getValue().split(":")[0];
- if (value!=null){
- classMap.get(className).getEnumType();
- enumType = classMap.get(className).getEnumType().containsKey(value);
- if (!enumType){
- workingMap = classMap.get(value).getRefAttribute();
- for ( Entry<String, String> subMab : workingMap.entrySet()){
- String value2 = subMab.getValue().split(":")[0];
- if (!subClassAttributes.containsValue(value2)){
- missingValues.put(subMab.getKey(), subMab.getValue());
- }
- }
-
- }
- }
- }
-
- return missingValues;
- }
-
- public Map<String, Map<String, String>> recursiveReference(Map<String, MSAttributeObject> classMap, String className){
-
- Map<String, Map<String, String>> returnObject = new HashMap<>();
- Map<String, String> returnClass = getRefclass(classMap, className);
- returnObject.put(className, returnClass);
- for (Entry<String, String> reAttribute :returnClass.entrySet()){
- if (reAttribute.getValue().split(":")[1].contains("MANY") &&
- classMap.get(reAttribute.getValue().split(":")[0]) != null){
- returnObject.putAll(recursiveReference(classMap, reAttribute.getValue().split(":")[0]));
- }
-
- }
-
- return returnObject;
-
- }
-
- public String createJson(Map<String, MSAttributeObject> classMap, String className) {
- boolean enumType;
- Map<String, Map<String, String>> myObject = new HashMap<>();
- for ( Entry<String, String> map : classMap.get(className).getRefAttribute().entrySet()){
- String value = map.getValue().split(":")[0];
- if (value!=null){
- enumType = classMap.get(className).getEnumType().containsKey(value);
- if (!enumType && map.getValue().split(":")[1].contains("MANY")){
- Map<String, Map<String, String>> testRecursive = recursiveReference(classMap, map.getValue().split(":")[0] );
- myObject.putAll(testRecursive);
- }
- }
- }
-
- Gson gson = new Gson();
- return gson.toJson(myObject);
- }
-
- public Map<String, String> getRefclass(Map<String, MSAttributeObject> classMap, String className){
- HashMap<String, String> missingValues = new HashMap<>();
-
- if (classMap.get(className).getAttribute()!=null || !classMap.get(className).getAttribute().isEmpty()){
- missingValues.putAll(classMap.get(className).getAttribute());
- }
-
- if (classMap.get(className).getRefAttribute()!=null || !classMap.get(className).getRefAttribute().isEmpty()){
- missingValues.putAll(classMap.get(className).getRefAttribute());
- }
-
- return missingValues;
- }
-
- public String createSubAttributes(List<String> dependency, Map<String, MSAttributeObject> classMap, String modelName) {
-
- HashMap <String, Object> workingMap = new HashMap<>();
- MSAttributeObject tempObject;
- if (dependency!=null){
- if (dependency.isEmpty()){
- return "{}";
- }
- dependency.add(modelName);
- for (String element: dependency){
- tempObject = classMap.get(element);
- if (tempObject!=null){
- workingMap.putAll(classMap.get(element).getSubClass());
- }
- }
- }
-
- return createJson(classMap, modelName);
- }
-
- public List<String> getFullDependencyList(List<String> dependency, Map<String,MSAttributeObject > classMap) {
- ArrayList<String> returnList = new ArrayList<>();
- ArrayList<String> workingList;
- returnList.addAll(dependency);
- for (String element : dependency ){
- if (classMap.containsKey(element)){
- MSAttributeObject value = classMap.get(element);
- String rawValue = StringUtils.replaceEach(value.getDependency(), new String[]{"[", "]"}, new String[]{"", ""});
- workingList = new ArrayList<>(Arrays.asList(rawValue.split(",")));
- for(String depend : workingList){
- if (!returnList.contains(depend) && !depend.isEmpty()){
- returnList.add(depend.trim());
- }
- }
- }
- }
-
- return returnList;
- }
-
+ private static final Log logger = LogFactory.getLog(MSModelUtils.class);
+
+ private HashMap<String,MSAttributeObject > classMap = new HashMap<>();
+ private HashMap<String, String> enumMap = new HashMap<>();
+ private HashMap<String, String> matchingClass = new HashMap<>();
+ private String configuration = "configuration";
+ private String dictionary = "dictionary";
+ private String onap = "";
+ private String policy = "";
+ private String eProxyURI = "eProxyURI:";
+ private List<String> orderedElements = new ArrayList<>();
+ private String dataOrderInfo = null;
+ private Set<String> uniqueDataKeys= new HashSet<>();
+ private Set<String> uniqueKeys= new HashSet<>();
+ private String listConstraints = null;
+ private String referenceAttributes;
+ private LinkedHashMap<String, Object> retmap = new LinkedHashMap<>();
+ private Map<String, String> matchableValues;
+ private static final String PROPERTIES=".properties.";
+ public static final String DATATYPE = "data_types.policy.data.";
+ public static final String TYPE=".type";
+ public static final String REQUIRED=".required";
+ private static final String MATCHABLE=".matchable";
+ private static final String STRING="string";
+ private static final String INTEGER="integer";
+ private static final String LIST="list";
+ public static final String MAP="map";
+ private static final String DEFAULT=".default";
+ private static final String MANYFALSE=":MANY-false";
+ private static final String MANYTRUE=":MANY-true";
+ private static final String DEFAULTVALUE=":defaultValue-";
+ private static final String REQUIREDVALUE=":required-";
+ private static final String MATCHABLEKEY="matchable";
+ private static final String REQUIREDFALSE=":required-false";
+ private static final String REQUIREDTRUE=":required-true";
+ private static final String MATCHINGTRUE="matching-true";
+
+ private StringBuilder dataListBuffer=new StringBuilder();
+ private List<String> dataConstraints= new ArrayList <>();
+ private String attributeString = null;
+
+ public MSModelUtils(){
+ }
+
+ public MSModelUtils(String onap, String policy){
+ this.onap = onap;
+ this.policy = policy;
+ }
+
+ private enum ANNOTATION_TYPE{
+ MATCHING, VALIDATION, DICTIONARY
+ };
+
+ public enum MODEL_TYPE {
+ XMI
+ };
+
+
+ public Map<String, MSAttributeObject> processEpackage(String file, MODEL_TYPE model){
+ if (model == MODEL_TYPE.XMI ){
+ processXMIEpackage(file);
+ }
+ return classMap;
+
+ }
+
+ private void processXMIEpackage(String xmiFile){
+ EPackage root = getEpackage(xmiFile);
+ TreeIterator<EObject> treeItr = root.eAllContents();
+ String className;
+ String returnValue;
+
+ // Pulling out dependency from file
+ while (treeItr.hasNext()) {
+ EObject obj = treeItr.next();
+ if (obj instanceof EClassifier) {
+ EClassifier eClassifier = (EClassifier) obj;
+ className = eClassifier.getName();
+
+ if (obj instanceof EEnum) {
+ enumMap.putAll(getEEnum(obj));
+ }else if (obj instanceof EClass) {
+ String temp = getDependencyList(eClassifier).toString();
+ returnValue = StringUtils.replaceEach(temp, new String[]{"[", "]"}, new String[]{"", ""});
+ getAttributes(className, returnValue, root);
+ }
+ }
+ }
+
+ if (!enumMap.isEmpty()){
+ addEnumClassMap();
+ }
+ if (!matchingClass.isEmpty()){
+ CheckForMatchingClass();
+ }
+ }
+
+ private void CheckForMatchingClass() {
+ HashMap<String, String> tempAttribute = new HashMap<>();
+
+ for (Entry<String, String> set : matchingClass.entrySet()){
+ String key = set.getKey();
+ if (classMap.containsKey(key)){
+ Map<String, String> listAttributes = classMap.get(key).getAttribute();
+ Map<String, String> listRef = classMap.get(key).getRefAttribute();
+ for ( Entry<String, String> eSet : listAttributes.entrySet()){
+ String key2 = eSet.getKey();
+ tempAttribute.put(key2, MATCHINGTRUE);
+ }
+ for ( Entry<String, String> eSet : listRef.entrySet()){
+ String key3 = eSet.getKey();
+ tempAttribute.put(key3, MATCHINGTRUE);
+ }
+
+ }
+ UpdateMatching(tempAttribute, key);
+ }
+
+ }
+
+
+
+ private void UpdateMatching(HashMap<String, String> tempAttribute, String key) {
+ Map<String, MSAttributeObject> newClass = classMap;
+
+ for (Entry<String, MSAttributeObject> updateClass : newClass.entrySet()){
+ Map<String, String> valueMap = updateClass.getValue().getMatchingSet();
+ String keymap = updateClass.getKey();
+ if (valueMap.containsKey(key)){
+ Map<String, String> modifyMap = classMap.get(keymap).getMatchingSet();
+ modifyMap.remove(key);
+ modifyMap.putAll(tempAttribute);
+ classMap.get(keymap).setMatchingSet(modifyMap);
+ }
+
+ }
+ }
+
+ private void addEnumClassMap() {
+ for (Entry<String, MSAttributeObject> value :classMap.entrySet()){
+ value.getValue().setEnumType(enumMap);
+ }
+ }
+
+ private EPackage getEpackage(String xmiFile) {
+ ResourceSet resSet = new ResourceSetImpl();
+ Resource.Factory.Registry reg = Resource.Factory.Registry.INSTANCE;
+ Map<String, Object> m = reg.getExtensionToFactoryMap();
+ m.put("xmi", new XMIResourceFactoryImpl());
+ Resource resource = resSet.getResource(URI.createFileURI(xmiFile), true);
+ try {
+ resource.load(Collections.emptyMap());
+ } catch (IOException e) {
+ logger.error("Error loading Encore Resource for new Model" + e);
+ }
+
+ return (EPackage) resource.getContents().get(0);
+ }
+
+ private HashMap<String, String> getEEnum(EObject obj) {
+ List<String> valueList = new ArrayList<>();
+ HashMap<String, String> returnMap = new HashMap<>();
+ EEnum eenum = (EEnum)obj;
+
+ String name = eenum.getName();
+ for (EEnumLiteral eEnumLiteral : eenum.getELiterals())
+ {
+ Enumerator instance = eEnumLiteral.getInstance();
+ String value = instance.getLiteral();
+ valueList.add(value);
+ }
+ returnMap.put(name, valueList.toString());
+ return returnMap;
+ }
+
+ public void getAttributes(String className, String dependency, EPackage root) {
+ List<String> dpendList = new ArrayList<>();
+ if (dependency!=null){
+ dpendList = new ArrayList<>(Arrays.asList(dependency.split(",")));
+ }
+ MSAttributeObject msAttributeObject = new MSAttributeObject();
+ msAttributeObject.setClassName(className);
+ String extendClass = getSubTypes(root, className);
+ Map<String, String> returnRefList = getRefAttributeList(root, className, extendClass);
+ Map<String, String> returnAttributeList = getAttributeList(root, className, extendClass);
+ Map<String, Object> returnSubList = getSubAttributeList(root, className, extendClass);
+ HashMap<String, String> returnAnnotation = getAnnotation(root, className, extendClass);
+ msAttributeObject.setAttribute(returnAttributeList);
+ msAttributeObject.setRefAttribute(returnRefList);
+ msAttributeObject.setSubClass(returnSubList);
+ msAttributeObject.setDependency(dpendList.toString());
+ msAttributeObject.addMatchingSet(returnAnnotation);
+ msAttributeObject.setPolicyTempalate(isPolicyTemplate(root, className));
+
+ this.classMap.put(className, msAttributeObject);
+ }
+
+ private HashMap<String, String> getAnnotation(EPackage root, String className, String extendClass) {
+ TreeIterator<EObject> treeItr = root.eAllContents();
+ boolean requiredAttribute = false;
+ boolean requiredMatchAttribute = false;
+ HashMap<String, String> annotationSet = new HashMap<>();
+
+ // Pulling out dependency from file
+ while (treeItr.hasNext()) {
+ EObject obj = treeItr.next();
+ if (obj instanceof EClassifier) {
+ requiredAttribute = isRequiredAttribute(obj, className );
+ requiredMatchAttribute = isRequiredAttribute(obj, extendClass );
+ }
+
+ if (requiredAttribute){
+ if (obj instanceof EStructuralFeature) {
+ checkAnnotation(annotationSet, (EStructuralFeature) obj);
+ }
+ } else if (requiredMatchAttribute && (obj instanceof EStructuralFeature)) {
+ findMatchingAnnotation(annotationSet, obj);
+ }
+ }
+ return annotationSet;
+ }
+
+ private void findMatchingAnnotation(HashMap<String, String> annotationSet, EObject obj) {
+ EStructuralFeature eStrucClassifier = (EStructuralFeature) obj;
+ if (eStrucClassifier.getEAnnotations().isEmpty()) {
+ return;
+ }
+ String matching = annotationValue(eStrucClassifier, ANNOTATION_TYPE.MATCHING, policy);
+ if (matching!=null){
+ if (obj instanceof EReference){
+ EClass refType = ((EReference) obj).getEReferenceType();
+ annotationSet.put(refType.getName(), matching);
+ matchingClass.put(refType.getName(), matching);
+ }else{
+ annotationSet.put(eStrucClassifier.getName(), matching);
+ }
+ }
+
+ }
+
+ private void checkAnnotation(HashMap<String, String> annotationSet, EStructuralFeature obj) {
+ EStructuralFeature eStrucClassifier = obj;
+ if (eStrucClassifier.getEAnnotations().isEmpty()) {
+ return;
+ }
+ String matching = annotationValue(eStrucClassifier, ANNOTATION_TYPE.MATCHING, policy);
+ if (matching!=null){
+ annotationSet.put(eStrucClassifier.getName(), matching);
+ }
+ String range = annotationValue(eStrucClassifier, ANNOTATION_TYPE.VALIDATION, policy);
+ if (range!=null){
+ annotationSet.put(eStrucClassifier.getName(), range);
+ }
+ String annotationDict = annotationValue(eStrucClassifier, ANNOTATION_TYPE.DICTIONARY, policy);
+ if (annotationDict!=null){
+ annotationSet.put(eStrucClassifier.getName(), annotationDict);
+ }
+ }
+
+ private Map<String, Object> getSubAttributeList(EPackage root, String className , String superClass) {
+ TreeIterator<EObject> treeItr = root.eAllContents();
+ boolean requiredAttribute = false;
+ Map<String, Object> subAttribute = new HashMap<>();
+ int rollingCount = 0;
+ int processClass = 0;
+
+ // Pulling out dependency from file
+ while (treeItr.hasNext() && rollingCount < 2) {
+
+ EObject obj = treeItr.next();
+ if (obj instanceof EClassifier) {
+ requiredAttribute = isRequiredAttribute(obj, className ) || isRequiredAttribute(obj, superClass );
+ if (requiredAttribute){
+ processClass++;
+ }
+ rollingCount = rollingCount+processClass;
+ }
+
+ if (requiredAttribute && (obj instanceof EStructuralFeature)) {
+ EStructuralFeature eStrucClassifier = (EStructuralFeature) obj;
+ if (!eStrucClassifier.getEAnnotations().isEmpty()) {
+ updateSubAttributes(subAttribute, obj, eStrucClassifier);
+ }
+ }
+ }
+ return subAttribute;
+ }
+
+ private void updateSubAttributes(Map<String, Object> subAttribute, EObject obj, EStructuralFeature eStrucClassifier) {
+ if (!(obj instanceof EReference)) {
+ return;
+ }
+ if (annotationTest(eStrucClassifier, configuration, onap)) {
+ EClass refType = ((EReference) obj).getEReferenceType();
+ if(!refType.toString().contains(eProxyURI)){
+ String required = REQUIREDFALSE;
+ if(eStrucClassifier.getLowerBound() == 1){
+ required = REQUIREDTRUE;
+ }
+ subAttribute.put(eStrucClassifier.getName(), refType.getName() + required);
+ }
+ }
+ }
+
+ public String checkDefultValue(String defultValue) {
+ if (defultValue!=null){
+ return DEFAULTVALUE+ defultValue;
+ }
+ return ":defaultValue-NA";
+
+ }
+
+ public String checkRequiredPattern(int upper, int lower) {
+
+ String pattern = XACMLProperties.getProperty(XACMLRestProperties.PROP_XCORE_REQUIRED_PATTERN);
+
+ if (pattern!=null){
+ if (upper == Integer.parseInt(pattern.split(",")[1]) && lower==Integer.parseInt(pattern.split(",")[0])){
+ return REQUIREDTRUE;
+ }
+ }
+
+ return REQUIREDFALSE;
+ }
+
+ public JSONObject buildJavaObject(Map<String, String> map){
+
+ return new JSONObject(map);
+ }
+
+ public Map<String, String> getRefAttributeList(EPackage root, String className, String superClass){
+
+ TreeIterator<EObject> treeItr = root.eAllContents();
+ boolean requiredAttribute = false;
+ HashMap<String, String> refAttribute = new HashMap<>();
+ int rollingCount = 0;
+ int processClass = 0;
+ boolean annotation;
+ // Pulling out dependency from file
+ while (treeItr.hasNext()) {
+ EObject obj = treeItr.next();
+ if (obj instanceof EClassifier) {
+ requiredAttribute = isRequiredAttribute(obj, className ) || isRequiredAttribute(obj, superClass );
+ if (requiredAttribute){
+ processClass++;
+ }
+ rollingCount = rollingCount+processClass;
+ }
+
+ if (requiredAttribute && (obj instanceof EStructuralFeature)) {
+ EStructuralFeature eStrucClassifier = (EStructuralFeature) obj;
+ if (!eStrucClassifier.getEAnnotations().isEmpty()) {
+ annotation = annotationTest(eStrucClassifier, configuration, onap);
+ if ( annotation && obj instanceof EReference) {
+ updRefAttributes(refAttribute, (EStructuralFeature) obj, eStrucClassifier);
+ } else if (annotation && obj instanceof EAttributeImpl) {
+ updEnumTypeRefAttrib(refAttribute, (EStructuralFeature) obj, eStrucClassifier);
+ }
+ }
+ }
+ }
+
+ return refAttribute;
+ }
+
+ private void updEnumTypeRefAttrib(HashMap<String, String> refAttribute, EStructuralFeature obj, EStructuralFeature eStrucClassifier) {
+ EClassifier refType = ((EAttributeImpl) obj).getEType();
+ if (!(refType instanceof EEnumImpl)){
+ return;
+ }
+
+ String array = arrayCheck(obj.getUpperBound());
+ String required = REQUIREDFALSE;
+ if(obj.getLowerBound() == 1){
+ required = REQUIREDTRUE;
+ }
+ refAttribute.put(eStrucClassifier.getName(), refType.getName() + array + required);
+ }
+
+ private void updRefAttributes(HashMap<String, String> refAttribute, EStructuralFeature obj, EStructuralFeature eStrucClassifier) {
+ EClass refType = ((EReference) obj).getEReferenceType();
+ if(refType.toString().contains(eProxyURI)){
+ String one = refType.toString().split(eProxyURI)[1];
+ String refValue = StringUtils.replaceEach(one.split("#")[1], new String[]{"//", ")"}, new String[]{"", ""});
+ refAttribute.put(eStrucClassifier.getName(), refValue);
+ } else {
+ String required = REQUIREDFALSE;
+ if(obj.getLowerBound() == 1){
+ required = REQUIREDTRUE;
+ }
+ refAttribute.put(eStrucClassifier.getName(), refType.getName() + arrayCheck(obj.getUpperBound()) + required);
+ }
+ }
+
+ private boolean annotationTest(EStructuralFeature eStrucClassifier, String annotation, String type) {
+ String annotationType;
+ EAnnotation eAnnotation;
+ String onapType;
+ String onapValue;
+
+ EList<EAnnotation> value = eStrucClassifier.getEAnnotations();
+
+ for (int i = 0; i < value.size(); i++){
+ annotationType = value.get(i).getSource();
+ eAnnotation = eStrucClassifier.getEAnnotations().get(i);
+ onapType = eAnnotation.getDetails().get(0).getValue();
+ onapValue = eAnnotation.getDetails().get(0).getKey();
+
+ if (annotationType.contains(type) && onapType.contains(annotation)){
+ return true;
+ }
+
+ if (annotationType.contains(type) && onapValue.contains(annotation)){
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+
+ private String annotationValue(EStructuralFeature eStrucClassifier, ANNOTATION_TYPE annotation, String type) {
+ String annotationType;
+ EAnnotation eAnnotation;
+ String onapType;
+ String onapValue = null;
+
+ EList<EAnnotation> value = eStrucClassifier.getEAnnotations();
+
+ for (int i = 0; i < value.size(); i++){
+ annotationType = value.get(i).getSource();
+ eAnnotation = eStrucClassifier.getEAnnotations().get(i);
+ onapType = eAnnotation.getDetails().get(0).getKey();
+ if (annotationType.contains(type) && onapType.compareToIgnoreCase(annotation.toString())==0){
+ onapValue = eAnnotation.getDetails().get(0).getValue();
+ if (annotation == ANNOTATION_TYPE.VALIDATION){
+ return onapValue;
+ } else {
+ return onapType + "-" + onapValue;
+ }
+ }
+ }
+
+ return onapValue;
+ }
+ public boolean isRequiredAttribute(EObject obj, String className){
+ EClassifier eClassifier = (EClassifier) obj;
+ String workingClass = eClassifier.getName().trim();
+ if (workingClass.equalsIgnoreCase(className)){
+ return true;
+ }
+
+ return false;
+ }
+
+ private boolean isPolicyTemplate(EPackage root, String className){
+ boolean result = false;
+ for (EClassifier classifier : root.getEClassifiers()){
+ if (classifier instanceof EClass) {
+ EClass eClass = (EClass)classifier;
+ if (eClass.getName().contentEquals(className)) {
+ result = checkPolicyTemplate(eClass);
+ break;
+ }
+ }
+ }
+ return result;
+ }
+
+ private boolean checkPolicyTemplate(EClass eClass) {
+ EList<EAnnotation> value = eClass.getEAnnotations();
+ for (EAnnotation workingValue : value){
+ EMap<String, String> keyMap = workingValue.getDetails();
+ if (keyMap.containsKey("policyTemplate")){
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private String getSubTypes(EPackage root, String className) {
+ String returnSubTypes = null;
+ for (EClassifier classifier : root.getEClassifiers()){
+ if (classifier instanceof EClass) {
+ returnSubTypes = findSubTypes(className, returnSubTypes, (EClass) classifier);
+ }
+ }
+ return returnSubTypes;
+ }
+
+ private String findSubTypes(String className, String returnSubTypes, EClass classifier) {
+ EClass eClass = classifier;
+
+ for (EClass eSuperType : eClass.getEAllSuperTypes())
+ {
+ if (eClass.getName().contentEquals(className)){
+ returnSubTypes = eSuperType.getName();
+ }
+ }
+ return returnSubTypes;
+ }
+
+ public Map<String, String> getAttributeList(EPackage root, String className, String superClass){
+
+ TreeIterator<EObject> treeItr = root.eAllContents();
+ boolean requiredAttribute = false;
+ HashMap<String, String> refAttribute = new HashMap<>();
+
+ // Pulling out dependency from file
+ while (treeItr.hasNext()) {
+ EObject obj = treeItr.next();
+ if (obj instanceof EClassifier) {
+ requiredAttribute = isRequiredAttribute(obj, className ) || isRequiredAttribute(obj, superClass );
+ }
+
+ if (requiredAttribute && (obj instanceof EStructuralFeature)) {
+ EStructuralFeature eStrucClassifier = (EStructuralFeature) obj;
+ if (!eStrucClassifier.getEAnnotations().isEmpty()) {
+ checkStrucClassifier(refAttribute, obj, eStrucClassifier);
+ }
+ }
+ }
+ return refAttribute;
+
+ }
+
+ private void checkStrucClassifier(HashMap<String, String> refAttribute, EObject obj, EStructuralFeature eStrucClassifier) {
+ EClassifier refType = ((EStructuralFeature) obj).getEType();
+ boolean annotation = annotationTest(eStrucClassifier, configuration, onap);
+ boolean dictionaryTest = annotationTest(eStrucClassifier, dictionary, policy);
+ if (annotation && !(obj instanceof EReference) && !(refType instanceof EEnumImpl)) {
+ updEReferenceAttrib(refAttribute, dictionaryTest, (EStructuralFeature) obj, eStrucClassifier);
+ }
+ }
+
+ private void updEReferenceAttrib(HashMap<String, String> refAttribute, boolean dictionaryTest, EStructuralFeature obj, EStructuralFeature eStrucClassifier) {
+ String eType;
+ String name = eStrucClassifier.getName();
+ if (dictionaryTest){
+ eType = annotationValue(eStrucClassifier, ANNOTATION_TYPE.DICTIONARY, policy);
+ }else {
+ eType = eStrucClassifier.getEType().getInstanceClassName();
+ }
+ String defaultValue = checkDefultValue(obj.getDefaultValueLiteral());
+ String array = arrayCheck(obj.getUpperBound());
+ String required = checkRequiredPattern(obj.getUpperBound(), obj.getLowerBound());
+ refAttribute.put(name, eType + defaultValue + required + array);
+ }
+
+ public String arrayCheck(int upperBound) {
+
+ if (upperBound == -1){
+ return MANYTRUE;
+ }
+
+ return MANYFALSE;
+ }
+
+ public List<String> getDependencyList(EClassifier eClassifier){
+ List<String> returnValue = new ArrayList<>();;
+ EList<EClass> somelist = ((EClass) eClassifier).getEAllSuperTypes();
+ if (somelist.isEmpty()){
+ return returnValue;
+ }
+ for(EClass depend: somelist){
+ if (depend.toString().contains(eProxyURI)){
+ String one = depend.toString().split(eProxyURI)[1];
+ String value = StringUtils.replaceEach(one.split("#")[1], new String[]{"//", ")"}, new String[]{"", ""});
+ returnValue.add(value);
+ }
+ }
+
+ return returnValue;
+ }
+
+ public Map<String, String> buildSubList(Map<String, String> subClassAttributes, Map<String, MSAttributeObject> classMap, String className){
+ Map<String, String> missingValues = new HashMap<>();
+ Map<String, String> workingMap;
+ boolean enumType;
+
+ for ( Entry<String, String> map : classMap.get(className).getRefAttribute().entrySet()){
+ String value = map.getValue().split(":")[0];
+ if (value!=null){
+ classMap.get(className).getEnumType();
+ enumType = classMap.get(className).getEnumType().containsKey(value);
+ if (!enumType){
+ workingMap = classMap.get(value).getRefAttribute();
+ for ( Entry<String, String> subMab : workingMap.entrySet()){
+ String value2 = subMab.getValue().split(":")[0];
+ if (!subClassAttributes.containsValue(value2)){
+ missingValues.put(subMab.getKey(), subMab.getValue());
+ }
+ }
+
+ }
+ }
+ }
+
+ return missingValues;
+ }
+
+ public Map<String, Map<String, String>> recursiveReference(Map<String, MSAttributeObject> classMap, String className){
+
+ Map<String, Map<String, String>> returnObject = new HashMap<>();
+ Map<String, String> returnClass = getRefclass(classMap, className);
+ returnObject.put(className, returnClass);
+ for (Entry<String, String> reAttribute :returnClass.entrySet()){
+ if (reAttribute.getValue().split(":")[1].contains("MANY") &&
+ classMap.get(reAttribute.getValue().split(":")[0]) != null){
+ returnObject.putAll(recursiveReference(classMap, reAttribute.getValue().split(":")[0]));
+ }
+
+ }
+
+ return returnObject;
+
+ }
+
+ public String createJson(Map<String, MSAttributeObject> classMap, String className) {
+ boolean enumType;
+ Map<String, Map<String, String>> myObject = new HashMap<>();
+ for ( Entry<String, String> map : classMap.get(className).getRefAttribute().entrySet()){
+ String value = map.getValue().split(":")[0];
+ if (value!=null){
+ enumType = classMap.get(className).getEnumType().containsKey(value);
+ if (!enumType && map.getValue().split(":")[1].contains("MANY")){
+ Map<String, Map<String, String>> testRecursive = recursiveReference(classMap, map.getValue().split(":")[0] );
+ myObject.putAll(testRecursive);
+ }
+ }
+ }
+
+ Gson gson = new Gson();
+ return gson.toJson(myObject);
+ }
+
+ public Map<String, String> getRefclass(Map<String, MSAttributeObject> classMap, String className){
+ HashMap<String, String> missingValues = new HashMap<>();
+
+ if (classMap.get(className).getAttribute()!=null || !classMap.get(className).getAttribute().isEmpty()){
+ missingValues.putAll(classMap.get(className).getAttribute());
+ }
+
+ if (classMap.get(className).getRefAttribute()!=null || !classMap.get(className).getRefAttribute().isEmpty()){
+ missingValues.putAll(classMap.get(className).getRefAttribute());
+ }
+
+ return missingValues;
+ }
+
+ public String createSubAttributes(List<String> dependency, Map<String, MSAttributeObject> classMap, String modelName) {
+
+ HashMap <String, Object> workingMap = new HashMap<>();
+ MSAttributeObject tempObject;
+ if (dependency!=null){
+ if (dependency.isEmpty()){
+ return "{}";
+ }
+ dependency.add(modelName);
+ for (String element: dependency){
+ tempObject = classMap.get(element);
+ if (tempObject!=null){
+ workingMap.putAll(classMap.get(element).getSubClass());
+ }
+ }
+ }
+
+ return createJson(classMap, modelName);
+ }
+
+ public List<String> getFullDependencyList(List<String> dependency, Map<String,MSAttributeObject > classMap) {
+ ArrayList<String> returnList = new ArrayList<>();
+ ArrayList<String> workingList;
+ returnList.addAll(dependency);
+ for (String element : dependency ){
+ if (classMap.containsKey(element)){
+ MSAttributeObject value = classMap.get(element);
+ String rawValue = StringUtils.replaceEach(value.getDependency(), new String[]{"[", "]"}, new String[]{"", ""});
+ workingList = new ArrayList<>(Arrays.asList(rawValue.split(",")));
+ for(String depend : workingList) {
+ updDependencyList(returnList, depend);
+ }
+ }
+ }
+
+ return returnList;
+ }
+
+ private void updDependencyList(ArrayList<String> returnList, String depend) {
+ if (!returnList.contains(depend) && !depend.isEmpty()){
+ returnList.add(depend.trim());
+ }
+ }
+
/*
* For TOSCA Model
*/
- public String parseTosca (String fileName){
- LinkedHashMap<String,String> map= new LinkedHashMap<>();
+ public String parseTosca (String fileName){
+ LinkedHashMap<String,String> map= new LinkedHashMap<>();
- try {
- map=load(fileName);
-
- if(map != null){
- if(map.get("error") != null){
- return map.get("error");
- }
- }
-
- parseDataAndPolicyNodes(map);
-
- LinkedHashMap<String,String> dataMapForJson=parseDataNodes(map);
-
- constructJsonForDataFields(dataMapForJson);
-
- LinkedHashMap<String,LinkedHashMap<String,String>> mapKey= parsePolicyNodes(map);
-
- createAttributes(mapKey);
-
- } catch (IOException e) {
- logger.error(e);
- }catch(ParserException e){
- logger.error(e);
- return e.getMessage();
- }
-
- return null;
- }
-
- @SuppressWarnings("unchecked")
- public LinkedHashMap<String, String> load(String fileName) throws IOException,ParserException {
- File newConfiguration = new File(fileName);
- StringBuilder orderInfo = new StringBuilder("[");
- Yaml yaml = new Yaml();
- LinkedHashMap<Object, Object> yamlMap = null;
- try(InputStream is = new FileInputStream(newConfiguration)){
- yamlMap = (LinkedHashMap<Object, Object>) yaml.load(is);
- } catch (FileNotFoundException e) {
- logger.error(e);
- }catch(Exception e){
- throw new ParserException("Invalid TOSCA Model format. Please make sure it is a valid YAML file");
- }
-
- StringBuilder sb = new StringBuilder();
- LinkedHashMap<String, String> settings = new LinkedHashMap<>();
- if (yamlMap == null) {
- return settings;
- }
-
- String message = validations(yamlMap);
-
- if(message != null){
- settings.put("error", message);
- return settings;
- }
-
- findNode(yamlMap);
-
- orderedElements.stream().forEach((string) -> {
- orderInfo.append(string);
- orderInfo.append(",");
- logger.info("Content: " + string);
- });
-
- orderInfo.append("]");
-
- dataOrderInfo = orderInfo.toString();
- dataOrderInfo = dataOrderInfo.replace(",]", "]");
-
- logger.info("dataOrderInfo :" + dataOrderInfo);
-
- List<String> path = new ArrayList <>();
- serializeMap(settings, sb, path, yamlMap);
- return settings;
- }
-
- @SuppressWarnings("unchecked")
- private String validations(@SuppressWarnings("rawtypes") LinkedHashMap yamlMap){
-
- boolean isNoteTypeFound = false;
- boolean isDataTypeFound = false;
- boolean isToscaVersionKeyFound = false;
- boolean isToscaVersionValueFound = false;
- @SuppressWarnings("rawtypes")
- Map m1 = new HashMap();
- short order =0;
- if(yamlMap != null){
- // Get a set of the entries
- @SuppressWarnings("rawtypes")
- Set set = yamlMap.entrySet();
- // Get an iterator
- @SuppressWarnings("rawtypes")
- Iterator i = set.iterator();
- // Display elements
- while(i.hasNext()) {
- @SuppressWarnings("rawtypes")
- Map.Entry me = (Map.Entry)i.next();
-
- if("tosca_definitions_version".equals(me.getKey())){
- isToscaVersionKeyFound = true;
- order++;
- m1.put("tosca_definitions_version", order);
- }
-
- if("tosca_simple_yaml_1_0_0".equals(me.getValue())){
- isToscaVersionValueFound = true;
- }
-
- if("node_types".equals(me.getKey())){
- isNoteTypeFound = true;
- order++;
- m1.put("node_types", order);
- }
-
- if("data_types".equals(me.getKey())){
- isDataTypeFound = true;
- order++;
- m1.put("data_types", order);
- }
-
- }
-
-
- if(!isDataTypeFound){
- return "data_types are missing or invalid.";
- }
-
- if(!isToscaVersionKeyFound || !isToscaVersionValueFound){
- return "tosca_definitions_version is missing or invalid.";
- }
-
- if(!isNoteTypeFound){
- return "node_types are missing or invalid.";
- }
-
- short version = (short) m1.get("tosca_definitions_version");
-
- if(version > 1 ){
- return "tosca_definitions_version should be defined first.";
- }
-
- short data = (short) m1.get("data_types");
- short node = (short) m1.get("node_types");
- if(node > data){
- return "node_types should be defined before data_types.";
- }
-
- }
-
- return null;
- }
-
- @SuppressWarnings({ "unchecked", "rawtypes" })
- private void serializeMap(LinkedHashMap<String, String> settings, StringBuilder sb, List<String> path, Map<Object, Object> yamlMap) {
- for (Map.Entry<Object, Object> entry : yamlMap.entrySet()) {
-
- if (entry.getValue() instanceof Map) {
- path.add((String) entry.getKey());
- serializeMap(settings, sb, path, (Map<Object, Object>) entry.getValue());
- path.remove(path.size() - 1);
- } else if (entry.getValue() instanceof List) {
- path.add((String) entry.getKey());
- serializeList(settings, sb, path, (List) entry.getValue());
- path.remove(path.size() - 1);
- } else {
- serializeValue(settings, sb, path, (String) entry.getKey(), entry.getValue());
- }
- }
- }
-
- @SuppressWarnings("unchecked")
- private void serializeList(LinkedHashMap<String, String> settings, StringBuilder sb, List<String> path, List<String> yamlList) {
- int counter = 0;
- for (Object listEle : yamlList) {
- if (listEle instanceof Map) {
- path.add(Integer.toString(counter));
- serializeMap(settings, sb, path, (Map<Object, Object>) listEle);
- path.remove(path.size() - 1);
- } else if (listEle instanceof List) {
- path.add(Integer.toString(counter));
- serializeList(settings, sb, path, (List<String>) listEle);
- path.remove(path.size() - 1);
- } else {
- serializeValue(settings, sb, path, Integer.toString(counter), listEle);
- }
- counter++;
- }
- }
-
- private void serializeValue(LinkedHashMap<String, String> settings, StringBuilder sb, List<String> path, String name, Object value) {
- if (value == null) {
- return;
- }
- sb.setLength(0);
- for (String pathEle : path) {
- sb.append(pathEle).append('.');
- }
- sb.append(name);
- settings.put(sb.toString(), value.toString());
- }
-
-
- void parseDataAndPolicyNodes(LinkedHashMap<String,String> map){
- for(String key:map.keySet()){
- if(key.contains("policy.nodes.Root"))
- {
- continue;
- }
- else if(key.contains("policy.nodes")){
- String wordToFind = "policy.nodes.";
- int indexForPolicyNode=key.indexOf(wordToFind);
- String subNodeString= key.substring(indexForPolicyNode+13, key.length());
-
- stringBetweenDots(subNodeString);
- }
- else if(key.contains("policy.data")){
- String wordToFind="policy.data.";
- int indexForPolicyNode=key.indexOf(wordToFind);
- String subNodeString= key.substring(indexForPolicyNode+12, key.length());
-
- stringBetweenDotsForDataFields(subNodeString);
- }
- }
- }
-
- // Second index of dot should be returned.
- public int stringBetweenDots(String str){
- String stringToSearch=str;
- String[]ss=stringToSearch.split("\\.");
- if(ss!=null){
- int len= ss.length;
- if(len>2){
- uniqueKeys.add(ss[2]);
- }
- }
-
- return uniqueKeys.size();
- }
-
-
- public void stringBetweenDotsForDataFields(String str){
- String stringToSearch=str;
- String[]ss=stringToSearch.split("\\.");
- if(ss!=null){
- int len= ss.length;
-
- if(len>2){
- uniqueDataKeys.add(ss[0]+"%"+ss[2]);
- }
- }
- }
-
- void constructJsonForDataFields(LinkedHashMap<String,String> dataMapForJson){
- LinkedHashMap<String,LinkedHashMap<String,String>> dataMapKey= new LinkedHashMap <>();
- LinkedHashMap<String, String> hmSub;
- for(Map.Entry<String, String> entry: dataMapForJson.entrySet()){
- String uniqueDataKey= entry.getKey();
- String[] uniqueDataKeySplit=uniqueDataKey.split("%");
- String value= dataMapForJson.get(uniqueDataKey);
- if(dataMapKey.containsKey(uniqueDataKeySplit[0])){
- hmSub = dataMapKey.get(uniqueDataKeySplit[0]);
- hmSub.put(uniqueDataKeySplit[1], value);
- }
- else{
- hmSub=new LinkedHashMap <>();
- hmSub.put(uniqueDataKeySplit[1], value);
- }
-
- dataMapKey.put(uniqueDataKeySplit[0], hmSub);
- }
-
- JSONObject mainObject= new JSONObject();
- JSONObject json;
- for(Map.Entry<String,LinkedHashMap<String,String>> entry: dataMapKey.entrySet()){
- String s=entry.getKey();
- json= new JSONObject();
- HashMap<String,String> jsonHm=dataMapKey.get(s);
- for(Map.Entry<String,String> entryMap:jsonHm.entrySet()){
- String key=entryMap.getKey();
- json.put(key, jsonHm.get(key));
- }
- mainObject.put(s,json);
- }
- Iterator<String> keysItr = mainObject.keys();
- while(keysItr.hasNext()) {
- String key = keysItr.next();
- String value = mainObject.get(key).toString();
- retmap.put(key, value);
- }
-
- logger.info("#############################################################################");
- logger.info(mainObject);
- logger.info("###############################################################################");
- }
- LinkedHashMap<String,String> parseDataNodes(LinkedHashMap<String,String> map){
- LinkedHashMap<String,String> dataMapForJson=new LinkedHashMap <>();
- matchableValues = new HashMap <>();
- for(String uniqueDataKey: uniqueDataKeys){
- if(uniqueDataKey.contains("%")){
- String[] uniqueDataKeySplit= uniqueDataKey.split("%");
- String findType=DATATYPE+uniqueDataKeySplit[0]+PROPERTIES+uniqueDataKeySplit[1]+TYPE;
- String typeValue=map.get(findType);
- logger.info(typeValue);
-
- String findRequired=DATATYPE+uniqueDataKeySplit[0]+PROPERTIES+uniqueDataKeySplit[1]+REQUIRED;
- String requiredValue= map.get(findRequired);
-
- String matchable =DATATYPE+uniqueDataKeySplit[0]+PROPERTIES+uniqueDataKeySplit[1]+MATCHABLE;
-
- String matchableValue= map.get(matchable);
-
- if(matchableValue != null && matchableValue.equalsIgnoreCase("true")){
- if(uniqueDataKey.contains("%")){
- String[] keys= uniqueDataKey.split("%");
- String key=keys[keys.length -1];
- matchableValues.put(key, MATCHINGTRUE);
- }else{
- matchableValues.put(uniqueDataKey, MATCHINGTRUE);
- }
- }
-
- if(requiredValue == null || requiredValue.isEmpty()){
- requiredValue = "false";
- }
- if(typeValue != null && (typeValue.equalsIgnoreCase(STRING)||
- typeValue.equalsIgnoreCase(INTEGER))){
-
- String findDefault=DATATYPE+uniqueDataKeySplit[0]+PROPERTIES+uniqueDataKeySplit[1]+DEFAULT;
- String defaultValue= map.get(findDefault);
- logger.info("defaultValue is:"+ defaultValue);
- logger.info("requiredValue is:"+ requiredValue);
-
- StringBuilder attributeIndividualStringBuilder= new StringBuilder();
- attributeIndividualStringBuilder.append(typeValue+DEFAULTVALUE);
- attributeIndividualStringBuilder.append(defaultValue+REQUIREDVALUE);
- attributeIndividualStringBuilder.append(requiredValue+MANYFALSE);
- dataMapForJson.put(uniqueDataKey, attributeIndividualStringBuilder.toString());
- }
- else if(LIST.equalsIgnoreCase(typeValue) || MAP.equalsIgnoreCase(typeValue)){
- logger.info("requiredValue is:"+ requiredValue);
- String findList= DATATYPE+uniqueDataKeySplit[0]+PROPERTIES+uniqueDataKeySplit[1]+".entry_schema.type";
- String listValue=map.get(findList);
- if(listValue!=null){
- logger.info("Type of list is:"+ listValue);
- //Its userdefined
- if(listValue.contains(".")){
- String trimValue=listValue.substring(listValue.lastIndexOf('.')+1);
- StringBuilder referenceIndividualStringBuilder= new StringBuilder();
- referenceIndividualStringBuilder.append(trimValue+REQUIREDVALUE);
- referenceIndividualStringBuilder.append(requiredValue+MANYTRUE);
- dataMapForJson.put(uniqueDataKey, referenceIndividualStringBuilder.toString());
- }//Its string
- else{
- StringBuilder stringListItems= new StringBuilder();
- if(LIST.equalsIgnoreCase(typeValue)){
- stringListItems.append(uniqueDataKeySplit[1].toUpperCase()+REQUIREDVALUE+requiredValue +MANYFALSE);
- }else if( MAP.equalsIgnoreCase(typeValue)){
- stringListItems.append(uniqueDataKeySplit[1].toUpperCase()+REQUIREDVALUE+requiredValue +MANYTRUE);
- }
- dataMapForJson.put(uniqueDataKey, stringListItems.toString());
- boolean isConstraintsFound = false;
- for(int i=0;i<10;i++){
- String findConstraints= DATATYPE+uniqueDataKeySplit[0]+PROPERTIES+uniqueDataKeySplit[1]+".entry_schema.constraints.0.valid_values."+i;
- logger.info("findConstraints => " + findConstraints);
- String constraintsValue=map.get(findConstraints);
- logger.info("constraintsValue => " + constraintsValue);
-
- if((constraintsValue==null || constraintsValue.isEmpty()) && i==0){ //if no constraints at all ( index i as 0 can tell this )
- isConstraintsFound = false;
- //if type is list but no constraints
- String newValue = dataMapForJson.get(uniqueDataKey).replace("MANY-false", "MANY-true");
- newValue = newValue.replace(uniqueDataKeySplit[1].toUpperCase()+":", "");
- dataMapForJson.put(uniqueDataKey, newValue);
- break;
- } else{
- isConstraintsFound = true;
- if(i == 0){ // only need to add one time for the same attribute
- dataListBuffer.append(uniqueDataKeySplit[1].toUpperCase()+"=[");
- }
-
- if(constraintsValue==null){
- constraintsValue = "";
- }else if (constraintsValue.contains("=")) {
- constraintsValue = constraintsValue.replace("=", "equal-sign");
- }
-
- dataConstraints.add(constraintsValue);
- dataListBuffer.append(constraintsValue+",");
- }
- }
- if(isConstraintsFound){
- dataListBuffer.append("]#");
- }
- }
- }else{
- logger.info("entry_schema.type is not defined correctly");
- }
- }
- else{
- String findUserDefined=DATATYPE+uniqueDataKeySplit[0]+"."+"properties"+"."+uniqueDataKeySplit[1]+TYPE;
- String userDefinedValue=map.get(findUserDefined);
- String trimValue=userDefinedValue.substring(userDefinedValue.lastIndexOf('.')+1);
- StringBuilder referenceIndividualStringBuilder= new StringBuilder();
- referenceIndividualStringBuilder.append(trimValue+REQUIREDVALUE);
- referenceIndividualStringBuilder.append(requiredValue+MANYFALSE);
- dataMapForJson.put(uniqueDataKey, referenceIndividualStringBuilder.toString());
-
- }
- }
- }
-
- return dataMapForJson;
- }
-
-
- LinkedHashMap<String, LinkedHashMap<String, String>> parsePolicyNodes(Map<String,String> map) throws ParserException{
- LinkedHashMap<String,LinkedHashMap<String,String>> mapKey= new LinkedHashMap <>();
- for(String uniqueKey: uniqueKeys){
- LinkedHashMap<String,String> hm;
-
- for(Map.Entry<String,String> entry:map.entrySet()){
- String key=entry.getKey();
- if(key.contains(uniqueKey) && key.contains("policy.nodes")){
- if(mapKey.containsKey(uniqueKey)){
- hm = mapKey.get(uniqueKey);
- String keyStr= key.substring(key.lastIndexOf('.')+1);
- String valueStr= map.get(key);
- if("type".equalsIgnoreCase(keyStr) && ((key.contains("entry_schema.0.type") || key.contains("entry_schema.type") && valueStr.contains("policy.data.")))){
- throw new ParserException("For using user defined object type, Please make sure no space between 'type:' and object " + valueStr );
-
- }
- if("type".equals(keyStr)){
- if(!key.contains("entry_schema"))
- {
- hm.put(keyStr,valueStr);
- }
- }else{
- hm.put(keyStr,valueStr);
- }
-
- } else {
- hm = new LinkedHashMap <>();
- String keyStr= key.substring(key.lastIndexOf('.')+1);
- String valueStr= map.get(key);
- if(key.contains(".objective.")){
- throw new ParserException("Attribute objective is a key word. Please use a different name");
- }
- if(("type").equals(keyStr)){
- if(!key.contains("entry_schema"))
- {
- hm.put(keyStr,valueStr);
- }
- }else{
- hm.put(keyStr,valueStr);
- }
- mapKey.put(uniqueKey, hm);
- }
- }
- }
- }
- return mapKey;
- }
-
- void createAttributes(LinkedHashMap<String,LinkedHashMap<String,String>> mapKey){
- StringBuilder attributeStringBuilder= new StringBuilder();
- StringBuilder referenceStringBuilder= new StringBuilder();
- StringBuilder listBuffer= new StringBuilder();
- List<String> constraints= new ArrayList<>();
- for(Map.Entry<String,LinkedHashMap<String,String>> entry: mapKey.entrySet()){
- String keySetString= entry.getKey();
- LinkedHashMap<String,String> keyValues=mapKey.get(keySetString);
- if(STRING.equalsIgnoreCase(keyValues.get("type"))||
- INTEGER.equalsIgnoreCase(keyValues.get("type"))){
- StringBuilder attributeIndividualStringBuilder= new StringBuilder();
- attributeIndividualStringBuilder.append(keySetString+"=");
- attributeIndividualStringBuilder.append(keyValues.get("type")+DEFAULTVALUE);
- attributeIndividualStringBuilder.append(keyValues.get("default")+REQUIREDVALUE);
- attributeIndividualStringBuilder.append(keyValues.get("required")+MANYFALSE);
- attributeStringBuilder.append(attributeIndividualStringBuilder+",");
+ try {
+ map=load(fileName);
+
+ if(map != null){
+ if(map.get("error") != null){
+ return map.get("error");
+ }
+ }
+
+ parseDataAndPolicyNodes(map);
+
+ LinkedHashMap<String,String> dataMapForJson=parseDataNodes(map);
+
+ constructJsonForDataFields(dataMapForJson);
+
+ LinkedHashMap<String,LinkedHashMap<String,String>> mapKey= parsePolicyNodes(map);
+
+ createAttributes(mapKey);
+
+ } catch (IOException e) {
+ logger.error(e);
+ }catch(ParserException e){
+ logger.error(e);
+ return e.getMessage();
+ }
+
+ return null;
+ }
+
+ @SuppressWarnings("unchecked")
+ public LinkedHashMap<String, String> load(String fileName) throws IOException,ParserException {
+ File newConfiguration = new File(fileName);
+ StringBuilder orderInfo = new StringBuilder("[");
+ Yaml yaml = new Yaml();
+ LinkedHashMap<Object, Object> yamlMap = null;
+ try(InputStream is = new FileInputStream(newConfiguration)){
+ yamlMap = (LinkedHashMap<Object, Object>) yaml.load(is);
+ } catch (FileNotFoundException e) {
+ logger.error(e);
+ }catch(Exception e){
+ throw new ParserException("Invalid TOSCA Model format. Please make sure it is a valid YAML file");
+ }
+
+ StringBuilder sb = new StringBuilder();
+ LinkedHashMap<String, String> settings = new LinkedHashMap<>();
+ if (yamlMap == null) {
+ return settings;
+ }
+
+ String message = validations(yamlMap);
+
+ if(message != null){
+ settings.put("error", message);
+ return settings;
+ }
+
+ findNode(yamlMap);
+
+ orderedElements.stream().forEach((string) -> {
+ orderInfo.append(string);
+ orderInfo.append(",");
+ logger.info("Content: " + string);
+ });
+
+ orderInfo.append("]");
+
+ dataOrderInfo = orderInfo.toString();
+ dataOrderInfo = dataOrderInfo.replace(",]", "]");
+
+ logger.info("dataOrderInfo :" + dataOrderInfo);
+
+ List<String> path = new ArrayList <>();
+ serializeMap(settings, sb, path, yamlMap);
+ return settings;
+ }
+
+ @SuppressWarnings("unchecked")
+ private String validations(@SuppressWarnings("rawtypes") LinkedHashMap yamlMap){
+
+ boolean isNoteTypeFound = false;
+ boolean isDataTypeFound = false;
+ boolean isToscaVersionKeyFound = false;
+ boolean isToscaVersionValueFound = false;
+ @SuppressWarnings("rawtypes")
+ Map m1 = new HashMap();
+ short order =0;
+ if(yamlMap != null){
+ // Get a set of the entries
+ @SuppressWarnings("rawtypes")
+ Set set = yamlMap.entrySet();
+ // Get an iterator
+ @SuppressWarnings("rawtypes")
+ Iterator i = set.iterator();
+ // Display elements
+ while(i.hasNext()) {
+ @SuppressWarnings("rawtypes")
+ Entry me = (Entry)i.next();
+
+ if("tosca_definitions_version".equals(me.getKey())){
+ isToscaVersionKeyFound = true;
+ order++;
+ m1.put("tosca_definitions_version", order);
+ }
+
+ if("tosca_simple_yaml_1_0_0".equals(me.getValue())){
+ isToscaVersionValueFound = true;
+ }
+
+ if("node_types".equals(me.getKey())){
+ isNoteTypeFound = true;
+ order++;
+ m1.put("node_types", order);
+ }
+
+ if("data_types".equals(me.getKey())){
+ isDataTypeFound = true;
+ order++;
+ m1.put("data_types", order);
+ }
+
+ }
+
+
+ if(!isDataTypeFound){
+ return "data_types are missing or invalid.";
+ }
+
+ if(!isToscaVersionKeyFound || !isToscaVersionValueFound){
+ return "tosca_definitions_version is missing or invalid.";
+ }
+
+ if(!isNoteTypeFound){
+ return "node_types are missing or invalid.";
+ }
+
+ short version = (short) m1.get("tosca_definitions_version");
+
+ if(version > 1 ){
+ return "tosca_definitions_version should be defined first.";
+ }
+
+ short data = (short) m1.get("data_types");
+ short node = (short) m1.get("node_types");
+ if(node > data){
+ return "node_types should be defined before data_types.";
+ }
+
+ }
+
+ return null;
+ }
+
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ private void serializeMap(LinkedHashMap<String, String> settings, StringBuilder sb, List<String> path, Map<Object, Object> yamlMap) {
+ for (Entry<Object, Object> entry : yamlMap.entrySet()) {
+
+ if (entry.getValue() instanceof Map) {
+ path.add((String) entry.getKey());
+ serializeMap(settings, sb, path, (Map<Object, Object>) entry.getValue());
+ path.remove(path.size() - 1);
+ } else if (entry.getValue() instanceof List) {
+ path.add((String) entry.getKey());
+ serializeList(settings, sb, path, (List) entry.getValue());
+ path.remove(path.size() - 1);
+ } else {
+ serializeValue(settings, sb, path, (String) entry.getKey(), entry.getValue());
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private void serializeList(LinkedHashMap<String, String> settings, StringBuilder sb, List<String> path, List<String> yamlList) {
+ int counter = 0;
+ for (Object listEle : yamlList) {
+ if (listEle instanceof Map) {
+ path.add(Integer.toString(counter));
+ serializeMap(settings, sb, path, (Map<Object, Object>) listEle);
+ path.remove(path.size() - 1);
+ } else if (listEle instanceof List) {
+ path.add(Integer.toString(counter));
+ serializeList(settings, sb, path, (List<String>) listEle);
+ path.remove(path.size() - 1);
+ } else {
+ serializeValue(settings, sb, path, Integer.toString(counter), listEle);
+ }
+ counter++;
+ }
+ }
+
+ private void serializeValue(LinkedHashMap<String, String> settings, StringBuilder sb, List<String> path, String name, Object value) {
+ if (value == null) {
+ return;
+ }
+ sb.setLength(0);
+ for (String pathEle : path) {
+ sb.append(pathEle).append('.');
+ }
+ sb.append(name);
+ settings.put(sb.toString(), value.toString());
+ }
+
+
+ void parseDataAndPolicyNodes(LinkedHashMap<String,String> map){
+ for(String key:map.keySet()){
+ if(key.contains("policy.nodes.Root"))
+ {
+ continue;
+ }
+ else if(key.contains("policy.nodes")){
+ String wordToFind = "policy.nodes.";
+ int indexForPolicyNode=key.indexOf(wordToFind);
+ String subNodeString= key.substring(indexForPolicyNode+13, key.length());
+
+ stringBetweenDots(subNodeString);
+ }
+ else if(key.contains("policy.data")){
+ String wordToFind="policy.data.";
+ int indexForPolicyNode=key.indexOf(wordToFind);
+ String subNodeString= key.substring(indexForPolicyNode+12, key.length());
+
+ stringBetweenDotsForDataFields(subNodeString);
+ }
+ }
+ }
+
+ // Second index of dot should be returned.
+ public int stringBetweenDots(String str){
+ String stringToSearch=str;
+ String[]ss=stringToSearch.split("\\.");
+ if(ss!=null){
+ int len= ss.length;
+ if(len>2){
+ uniqueKeys.add(ss[2]);
+ }
+ }
+
+ return uniqueKeys.size();
+ }
+
+
+ public void stringBetweenDotsForDataFields(String str){
+ String stringToSearch=str;
+ String[]ss=stringToSearch.split("\\.");
+ if(ss!=null){
+ int len= ss.length;
+
+ if(len>2){
+ uniqueDataKeys.add(ss[0]+"%"+ss[2]);
+ }
+ }
+ }
+
+ void constructJsonForDataFields(LinkedHashMap<String,String> dataMapForJson){
+ LinkedHashMap<String,LinkedHashMap<String,String>> dataMapKey= new LinkedHashMap <>();
+ LinkedHashMap<String, String> hmSub;
+ for(Entry<String, String> entry: dataMapForJson.entrySet()){
+ String uniqueDataKey= entry.getKey();
+ String[] uniqueDataKeySplit=uniqueDataKey.split("%");
+ String value= dataMapForJson.get(uniqueDataKey);
+ if(dataMapKey.containsKey(uniqueDataKeySplit[0])){
+ hmSub = dataMapKey.get(uniqueDataKeySplit[0]);
+ hmSub.put(uniqueDataKeySplit[1], value);
+ }
+ else{
+ hmSub=new LinkedHashMap <>();
+ hmSub.put(uniqueDataKeySplit[1], value);
+ }
+
+ dataMapKey.put(uniqueDataKeySplit[0], hmSub);
+ }
+
+ JSONObject mainObject= new JSONObject();
+ JSONObject json;
+ for(Entry<String,LinkedHashMap<String,String>> entry: dataMapKey.entrySet()){
+ String s=entry.getKey();
+ json= new JSONObject();
+ HashMap<String,String> jsonHm=dataMapKey.get(s);
+ for(Entry<String,String> entryMap:jsonHm.entrySet()){
+ String key=entryMap.getKey();
+ json.put(key, jsonHm.get(key));
+ }
+ mainObject.put(s,json);
+ }
+ Iterator<String> keysItr = mainObject.keys();
+ while(keysItr.hasNext()) {
+ String key = keysItr.next();
+ String value = mainObject.get(key).toString();
+ retmap.put(key, value);
+ }
+
+ logger.info("#############################################################################");
+ logger.info(mainObject);
+ logger.info("###############################################################################");
+ }
+ LinkedHashMap<String,String> parseDataNodes(LinkedHashMap<String,String> map){
+ LinkedHashMap<String,String> dataMapForJson=new LinkedHashMap <>();
+ matchableValues = new HashMap <>();
+ for(String uniqueDataKey: uniqueDataKeys){
+ if(uniqueDataKey.contains("%")){
+ String[] uniqueDataKeySplit= uniqueDataKey.split("%");
+ String findType=DATATYPE+uniqueDataKeySplit[0]+PROPERTIES+uniqueDataKeySplit[1]+TYPE;
+ String typeValue=map.get(findType);
+ logger.info(typeValue);
+
+ String findRequired=DATATYPE+uniqueDataKeySplit[0]+PROPERTIES+uniqueDataKeySplit[1]+REQUIRED;
+ String requiredValue= map.get(findRequired);
+
+ String matchable =DATATYPE+uniqueDataKeySplit[0]+PROPERTIES+uniqueDataKeySplit[1]+MATCHABLE;
+
+ String matchableValue= map.get(matchable);
+
+ if(matchableValue != null && matchableValue.equalsIgnoreCase("true")){
+ if(uniqueDataKey.contains("%")){
+ String[] keys= uniqueDataKey.split("%");
+ String key=keys[keys.length -1];
+ matchableValues.put(key, MATCHINGTRUE);
+ }else{
+ matchableValues.put(uniqueDataKey, MATCHINGTRUE);
+ }
+ }
+
+ if(requiredValue == null || requiredValue.isEmpty()){
+ requiredValue = "false";
+ }
+ if(typeValue != null && (typeValue.equalsIgnoreCase(STRING)||
+ typeValue.equalsIgnoreCase(INTEGER))){
+
+ String findDefault=DATATYPE+uniqueDataKeySplit[0]+PROPERTIES+uniqueDataKeySplit[1]+DEFAULT;
+ String defaultValue= map.get(findDefault);
+ logger.info("defaultValue is:"+ defaultValue);
+ logger.info("requiredValue is:"+ requiredValue);
+
+ StringBuilder attributeIndividualStringBuilder= new StringBuilder();
+ attributeIndividualStringBuilder.append(typeValue+DEFAULTVALUE);
+ attributeIndividualStringBuilder.append(defaultValue+REQUIREDVALUE);
+ attributeIndividualStringBuilder.append(requiredValue+MANYFALSE);
+ dataMapForJson.put(uniqueDataKey, attributeIndividualStringBuilder.toString());
+ }
+ else if(LIST.equalsIgnoreCase(typeValue) || MAP.equalsIgnoreCase(typeValue)){
+ logger.info("requiredValue is:"+ requiredValue);
+ String findList= DATATYPE+uniqueDataKeySplit[0]+PROPERTIES+uniqueDataKeySplit[1]+".entry_schema.type";
+ String listValue=map.get(findList);
+ if(listValue!=null){
+ logger.info("Type of list is:"+ listValue);
+ //Its userdefined
+ if(listValue.contains(".")){
+ String trimValue=listValue.substring(listValue.lastIndexOf('.')+1);
+ StringBuilder referenceIndividualStringBuilder= new StringBuilder();
+ referenceIndividualStringBuilder.append(trimValue+REQUIREDVALUE);
+ referenceIndividualStringBuilder.append(requiredValue+MANYTRUE);
+ dataMapForJson.put(uniqueDataKey, referenceIndividualStringBuilder.toString());
+ }//Its string
+ else{
+ StringBuilder stringListItems= new StringBuilder();
+ if(LIST.equalsIgnoreCase(typeValue)){
+ stringListItems.append(uniqueDataKeySplit[1].toUpperCase()+REQUIREDVALUE+requiredValue +MANYFALSE);
+ }else if( MAP.equalsIgnoreCase(typeValue)){
+ stringListItems.append(uniqueDataKeySplit[1].toUpperCase()+REQUIREDVALUE+requiredValue +MANYTRUE);
+ }
+ dataMapForJson.put(uniqueDataKey, stringListItems.toString());
+ boolean isConstraintsFound = false;
+ for(int i=0;i<10;i++){
+ String findConstraints= DATATYPE+uniqueDataKeySplit[0]+PROPERTIES+uniqueDataKeySplit[1]+".entry_schema.constraints.0.valid_values."+i;
+ logger.info("findConstraints => " + findConstraints);
+ String constraintsValue=map.get(findConstraints);
+ logger.info("constraintsValue => " + constraintsValue);
+
+ if((constraintsValue==null || constraintsValue.isEmpty()) && i==0){ //if no constraints at all ( index i as 0 can tell this )
+ isConstraintsFound = false;
+ //if type is list but no constraints
+ String newValue = dataMapForJson.get(uniqueDataKey).replace("MANY-false", "MANY-true");
+ newValue = newValue.replace(uniqueDataKeySplit[1].toUpperCase()+":", "");
+ dataMapForJson.put(uniqueDataKey, newValue);
+ break;
+ } else{
+ isConstraintsFound = true;
+ if(i == 0){ // only need to add one time for the same attribute
+ dataListBuffer.append(uniqueDataKeySplit[1].toUpperCase()+"=[");
+ }
+
+ if(constraintsValue==null){
+ constraintsValue = "";
+ }else if (constraintsValue.contains("=")) {
+ constraintsValue = constraintsValue.replace("=", "equal-sign");
+ }
+
+ dataConstraints.add(constraintsValue);
+ dataListBuffer.append(constraintsValue+",");
+ }
+ }
+ if(isConstraintsFound){
+ dataListBuffer.append("]#");
+ }
+ }
+ }else{
+ logger.info("entry_schema.type is not defined correctly");
+ }
+ }
+ else{
+ String findUserDefined=DATATYPE+uniqueDataKeySplit[0]+"."+"properties"+"."+uniqueDataKeySplit[1]+TYPE;
+ String userDefinedValue=map.get(findUserDefined);
+ String trimValue=userDefinedValue.substring(userDefinedValue.lastIndexOf('.')+1);
+ StringBuilder referenceIndividualStringBuilder= new StringBuilder();
+ referenceIndividualStringBuilder.append(trimValue+REQUIREDVALUE);
+ referenceIndividualStringBuilder.append(requiredValue+MANYFALSE);
+ dataMapForJson.put(uniqueDataKey, referenceIndividualStringBuilder.toString());
+
+ }
+ }
+ }
+
+ return dataMapForJson;
+ }
+
+
+ LinkedHashMap<String, LinkedHashMap<String, String>> parsePolicyNodes(Map<String,String> map) throws ParserException{
+ LinkedHashMap<String,LinkedHashMap<String,String>> mapKey= new LinkedHashMap <>();
+ for(String uniqueKey: uniqueKeys){
+ LinkedHashMap<String,String> hm;
+
+ for(Entry<String,String> entry:map.entrySet()){
+ String key=entry.getKey();
+ if(key.contains(uniqueKey) && key.contains("policy.nodes")){
+ if(mapKey.containsKey(uniqueKey)){
+ hm = mapKey.get(uniqueKey);
+ String keyStr= key.substring(key.lastIndexOf('.')+1);
+ String valueStr= map.get(key);
+ if("type".equalsIgnoreCase(keyStr) && ((key.contains("entry_schema.0.type") || key.contains("entry_schema.type") && valueStr.contains("policy.data.")))){
+ throw new ParserException("For using user defined object type, Please make sure no space between 'type:' and object " + valueStr );
+
+ }
+ if("type".equals(keyStr)){
+ if(!key.contains("entry_schema"))
+ {
+ hm.put(keyStr,valueStr);
+ }
+ }else{
+ hm.put(keyStr,valueStr);
+ }
+
+ } else {
+ hm = new LinkedHashMap <>();
+ String keyStr= key.substring(key.lastIndexOf('.')+1);
+ String valueStr= map.get(key);
+ if(key.contains(".objective.")){
+ throw new ParserException("Attribute objective is a key word. Please use a different name");
+ }
+ if(("type").equals(keyStr)){
+ if(!key.contains("entry_schema"))
+ {
+ hm.put(keyStr,valueStr);
+ }
+ }else{
+ hm.put(keyStr,valueStr);
+ }
+ mapKey.put(uniqueKey, hm);
+ }
+ }
+ }
+ }
+ return mapKey;
+ }
+
+ void createAttributes(LinkedHashMap<String,LinkedHashMap<String,String>> mapKey){
+ StringBuilder attributeStringBuilder= new StringBuilder();
+ StringBuilder referenceStringBuilder= new StringBuilder();
+ StringBuilder listBuffer= new StringBuilder();
+ List<String> constraints= new ArrayList<>();
+ for(Entry<String,LinkedHashMap<String,String>> entry: mapKey.entrySet()){
+ String keySetString= entry.getKey();
+ LinkedHashMap<String,String> keyValues=mapKey.get(keySetString);
+ if(STRING.equalsIgnoreCase(keyValues.get("type"))||
+ INTEGER.equalsIgnoreCase(keyValues.get("type"))){
+ StringBuilder attributeIndividualStringBuilder= new StringBuilder();
+ attributeIndividualStringBuilder.append(keySetString+"=");
+ attributeIndividualStringBuilder.append(keyValues.get("type")+DEFAULTVALUE);
+ attributeIndividualStringBuilder.append(keyValues.get("default")+REQUIREDVALUE);
+ attributeIndividualStringBuilder.append(keyValues.get("required")+MANYFALSE);
+ attributeStringBuilder.append(attributeIndividualStringBuilder+",");
if("true".equalsIgnoreCase(keyValues.get(MATCHABLEKEY))){
- matchableValues.put(keySetString, MATCHINGTRUE);
+ matchableValues.put(keySetString, MATCHINGTRUE);
}
- }
- else if(LIST.equalsIgnoreCase(keyValues.get("type"))){
-
+ }
+ else if(LIST.equalsIgnoreCase(keyValues.get("type"))){
+
if(("true").equalsIgnoreCase(keyValues.get(MATCHABLEKEY))){
- matchableValues.put(keySetString, MATCHINGTRUE);
+ matchableValues.put(keySetString, MATCHINGTRUE);
+ }
+ //List Datatype
+ Set<String> keys= keyValues.keySet();
+ Iterator<String> itr=keys.iterator();
+ boolean isDefinedType = false;
+ while(itr.hasNext()){
+ String key= itr.next();
+ if((!("type").equals(key) ||("required").equals(key)))
+ {
+ String value= keyValues.get(key);
+ //The "." in the value determines if its a string or a user defined type.
+ if (!value.contains(".")){
+ //This is string
+ if(StringUtils.isNumeric(key) ){ //only integer key for the value of Constrains
+ constraints.add(keyValues.get(key));
+ }
+ }else{
+ //This is user defined type
+ String trimValue=value.substring(value.lastIndexOf('.')+1);
+ StringBuilder referenceIndividualStringBuilder= new StringBuilder();
+ referenceIndividualStringBuilder.append(keySetString+"="+trimValue+MANYTRUE);
+ referenceStringBuilder.append(referenceIndividualStringBuilder+",");
+ isDefinedType = true;
+ }
+ }
+
}
- //List Datatype
- Set<String> keys= keyValues.keySet();
- Iterator<String> itr=keys.iterator();
- boolean isDefinedType = false;
- while(itr.hasNext()){
- String key= itr.next();
- if((!("type").equals(key) ||("required").equals(key)))
- {
- String value= keyValues.get(key);
- //The "." in the value determines if its a string or a user defined type.
- if (!value.contains(".")){
- //This is string
- if(StringUtils.isNumeric(key) ){ //only integer key for the value of Constrains
- constraints.add(keyValues.get(key));
- }
- }else{
- //This is user defined type
- String trimValue=value.substring(value.lastIndexOf('.')+1);
- StringBuilder referenceIndividualStringBuilder= new StringBuilder();
- referenceIndividualStringBuilder.append(keySetString+"="+trimValue+MANYTRUE);
- referenceStringBuilder.append(referenceIndividualStringBuilder+",");
- isDefinedType = true;
- }
- }
-
- }
-
- if(!isDefinedType && LIST.equalsIgnoreCase(keyValues.get("type"))){ //type is not user defined and is a list but no constraints defined.
- if(constraints == null || constraints.isEmpty()){
- referenceStringBuilder.append(keySetString+"=MANY-true"+",");
- }
- }
- }else{
- //User defined Datatype.
+
+ if(!isDefinedType && LIST.equalsIgnoreCase(keyValues.get("type"))){ //type is not user defined and is a list but no constraints defined.
+ if(constraints == null || constraints.isEmpty()){
+ referenceStringBuilder.append(keySetString+"=MANY-true"+",");
+ }
+ }
+ }else{
+ //User defined Datatype.
if("true".equalsIgnoreCase(keyValues.get(MATCHABLEKEY))){
- matchableValues.put(keySetString, MATCHINGTRUE);
+ matchableValues.put(keySetString, MATCHINGTRUE);
+ }
+ String value=keyValues.get("type");
+ if(value != null && !value.isEmpty()){
+ String trimValue=value.substring(value.lastIndexOf('.')+1);
+ StringBuilder referenceIndividualStringBuilder= new StringBuilder();
+ referenceIndividualStringBuilder.append(keySetString+"="+trimValue+MANYFALSE);
+ referenceStringBuilder.append(referenceIndividualStringBuilder+",");
+ }else{
+ logger.info("keyValues.get(type) is null/empty");
+ }
+
+ }
+ if(constraints!=null && !constraints.isEmpty()){
+ //List handling.
+ listBuffer.append(keySetString.toUpperCase()+"=[");
+ for(String str:constraints){
+ listBuffer.append(str+",");
}
- String value=keyValues.get("type");
- if(value != null && !value.isEmpty()){
- String trimValue=value.substring(value.lastIndexOf('.')+1);
- StringBuilder referenceIndividualStringBuilder= new StringBuilder();
- referenceIndividualStringBuilder.append(keySetString+"="+trimValue+MANYFALSE);
- referenceStringBuilder.append(referenceIndividualStringBuilder+",");
- }else{
- logger.info("keyValues.get(type) is null/empty");
- }
-
- }
- if(constraints!=null && !constraints.isEmpty()){
- //List handling.
- listBuffer.append(keySetString.toUpperCase()+"=[");
- for(String str:constraints){
- listBuffer.append(str+",");
- }
- listBuffer.append("]#");
- logger.info(listBuffer);
-
-
- StringBuilder referenceIndividualStringBuilder= new StringBuilder();
- referenceIndividualStringBuilder.append(keySetString+"="+keySetString.toUpperCase()+MANYFALSE);
- referenceStringBuilder.append(referenceIndividualStringBuilder+",");
- constraints.clear();
- }
- }
-
- dataListBuffer.append(listBuffer);
-
-
- logger.info("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
- logger.info("Whole attribute String is:"+attributeStringBuilder);
- logger.info("Whole reference String is:"+referenceStringBuilder);
- logger.info("List String is:"+listBuffer);
- logger.info("Data list buffer is:"+dataListBuffer);
- logger.info("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
-
- this.listConstraints=dataListBuffer.toString();
- this.referenceAttributes=referenceStringBuilder.toString();
- this.attributeString=attributeStringBuilder.toString();
- }
-
- @SuppressWarnings("unchecked")
- public void findNode(LinkedHashMap<Object, Object> map) {
-
- map.forEach((key,value) -> {
- // if the value is properties and its type is map object, then save all the keys
- if(key.equals("properties") && value instanceof Map){
- saveNodes((LinkedHashMap<?, ?>)value);
- }
-
- if(!key.equals("policy.nodes.Root") && value instanceof Map){
- //value is a Map object, then make a recursive call
- findNode((LinkedHashMap<Object, Object>) value);
- }
- });
-
- }
-
- public void saveNodes(LinkedHashMap<?, ?> map) {
-
- map.forEach((key,value) -> {
-
- orderedElements.add((String)key);
-
- });
-
- }
-
- public String getAttributeString() {
- return attributeString;
- }
- public void setAttributeString(String attributeString) {
- this.attributeString = attributeString;
- }
-
- public LinkedHashMap<String, Object> getRetmap() {
- return retmap;
- }
-
- public void setRetmap(LinkedHashMap<String, Object> retmap) {
- this.retmap = retmap;
- }
- public Map<String, String> getMatchableValues() {
- return matchableValues;
- }
-
- public void setMatchableValues(Map<String, String> matchableValues) {
- this.matchableValues = matchableValues;
- }
- public String getReferenceAttributes() {
- return referenceAttributes;
- }
-
- public void setReferenceAttributes(String referenceAttributes) {
- this.referenceAttributes = referenceAttributes;
- }
- public String getListConstraints() {
- return listConstraints;
- }
-
- public void setListConstraints(String listConstraints) {
- this.listConstraints = listConstraints;
- }
- public String getDataOrderInfo() {
- return dataOrderInfo;
- }
-
- public void setDataOrderInfo(String dataOrderInfo) {
- this.dataOrderInfo = dataOrderInfo;
- }
+ listBuffer.append("]#");
+ logger.info(listBuffer);
+
+
+ StringBuilder referenceIndividualStringBuilder= new StringBuilder();
+ referenceIndividualStringBuilder.append(keySetString+"="+keySetString.toUpperCase()+MANYFALSE);
+ referenceStringBuilder.append(referenceIndividualStringBuilder+",");
+ constraints.clear();
+ }
+ }
+
+ dataListBuffer.append(listBuffer);
+
+
+ logger.info("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
+ logger.info("Whole attribute String is:"+attributeStringBuilder);
+ logger.info("Whole reference String is:"+referenceStringBuilder);
+ logger.info("List String is:"+listBuffer);
+ logger.info("Data list buffer is:"+dataListBuffer);
+ logger.info("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
+
+ this.listConstraints=dataListBuffer.toString();
+ this.referenceAttributes=referenceStringBuilder.toString();
+ this.attributeString=attributeStringBuilder.toString();
+ }
+
+ @SuppressWarnings("unchecked")
+ public void findNode(LinkedHashMap<Object, Object> map) {
+
+ map.forEach((key,value) -> {
+ // if the value is properties and its type is map object, then save all the keys
+ if(key.equals("properties") && value instanceof Map){
+ saveNodes((LinkedHashMap<?, ?>)value);
+ }
+
+ if(!key.equals("policy.nodes.Root") && value instanceof Map){
+ //value is a Map object, then make a recursive call
+ findNode((LinkedHashMap<Object, Object>) value);
+ }
+ });
+
+ }
+
+ public void saveNodes(LinkedHashMap<?, ?> map) {
+
+ map.forEach((key,value) -> {
+
+ orderedElements.add((String)key);
+
+ });
+
+ }
+
+ public String getAttributeString() {
+ return attributeString;
+ }
+ public void setAttributeString(String attributeString) {
+ this.attributeString = attributeString;
+ }
+
+ public LinkedHashMap<String, Object> getRetmap() {
+ return retmap;
+ }
+
+ public void setRetmap(LinkedHashMap<String, Object> retmap) {
+ this.retmap = retmap;
+ }
+ public Map<String, String> getMatchableValues() {
+ return matchableValues;
+ }
+
+ public void setMatchableValues(Map<String, String> matchableValues) {
+ this.matchableValues = matchableValues;
+ }
+ public String getReferenceAttributes() {
+ return referenceAttributes;
+ }
+
+ public void setReferenceAttributes(String referenceAttributes) {
+ this.referenceAttributes = referenceAttributes;
+ }
+ public String getListConstraints() {
+ return listConstraints;
+ }
+
+ public void setListConstraints(String listConstraints) {
+ this.listConstraints = listConstraints;
+ }
+ public String getDataOrderInfo() {
+ return dataOrderInfo;
+ }
+
+ public void setDataOrderInfo(String dataOrderInfo) {
+ this.dataOrderInfo = dataOrderInfo;
+ }
} \ No newline at end of file