--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP-REST
+ * ================================================================================
+ * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
+ * Modified Copyright (C) 2018 Samsung Electronics Co., Ltd.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.rest.util;
+
+import com.att.research.xacml.util.XACMLProperties;
+import com.google.gson.Gson;
+
+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.Map.Entry;
+import java.util.Set;
+
+import lombok.Getter;
+import lombok.Setter;
+
+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.ecore.impl.EAttributeImpl;
+import org.eclipse.emf.ecore.impl.EEnumImpl;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
+import org.json.JSONObject;
+import org.onap.policy.rest.XacmlRestProperties;
+import org.onap.policy.rest.dao.CommonClassDao;
+import org.onap.policy.rest.jpa.DictionaryData;
+import org.yaml.snakeyaml.Yaml;
+
+@Getter
+@Setter
+public class MsModelUtils {
+
+ private static final Log logger = LogFactory.getLog(MsModelUtils.class);
+
+ // String constants
+ private static final String BOOLEAN = "boolean";
+ private static final String CONFIGURATION = "configuration";
+ private static final String DATATYPE = "data_types.policy.data.";
+ private static final String DATA_TYPE = "data_types";
+ private static final String DEFAULT = ".default";
+ private static final String DEFAULTVALUE = ":defaultValue-";
+ private static final String DESCRIPTION = ".description";
+ private static final String DESCRIPTION_KEY = "description";
+ private static final String DESCRIPTION_TOKEN = ":description-";
+ private static final String DICTIONARY = "dictionary:";
+ private static final String DICTIONARYNAME = "dictionaryName";
+ private static final String ERROR = "error";
+ private static final String E_PROXY_URI = "eProxyURI:";
+ private static final String INTEGER = "integer";
+ private static final String JSON_MODEL = "JSON_MODEL";
+ private static final String LIST = "list";
+ private static final String MANYFALSE = ":MANY-false";
+ private static final String MANYTRUE = ":MANY-true";
+ private static final String MAP = "map";
+ private static final String MATCHABLE = ".matchable";
+ private static final String MATCHABLEKEY = "matchable";
+ private static final String MATCHINGTRUE = "matching-true";
+ private static final String NODE_TYPE = "node_types";
+ private static final String PROPERTIES = ".properties.";
+ private static final String PROPERTIES_KEY = "properties";
+ private static final String REQUIRED = ".required";
+ private static final String REQUIREDFALSE = ":required-false";
+ private static final String REQUIREDTRUE = ":required-true";
+ private static final String REQUIREDVALUE = ":required-";
+ private static final String STRING = "string";
+ private static final String TOSCA_DEFINITION_VERSION = "tosca_definitions_version";
+ private static final String TOSCA_SIMPLE_YAML_1_0_0 = "tosca_simple_yaml_1_0_0";
+ private static final String TYPE = ".type";
+
+ private static CommonClassDao commonClassDao;
+
+ private HashMap<String, MsAttributeObject> classMap = new HashMap<>();
+ private HashMap<String, String> enumMap = new HashMap<>();
+ private HashMap<String, String> matchingClass = new HashMap<>();
+ private String onap = "";
+ private String policy = "";
+ private List<String> orderedElements = new ArrayList<>();
+ private String dataOrderInfo = "";
+ 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 StringBuilder dataListBuffer = new StringBuilder();
+ private List<String> dataConstraints = new ArrayList<>();
+ private String attributeString = null;
+ private boolean isDuplicatedAttributes = false;
+ private String jsonRuleFormation = null;
+
+ /**
+ * The Enum AnnotationType.
+ */
+ private enum AnnotationType {
+ MATCHING,
+ VALIDATION,
+ DICTIONARY
+ }
+
+ /**
+ * The Enum ModelType.
+ */
+ public enum ModelType {
+ XMI
+ }
+
+ /**
+ * The Enum SearchType.
+ */
+ public enum SearchType {
+ TOSCA_DEFINITION_VERSION,
+ TOSCA_SIMPLE_YAML_1_0_0,
+ NODE_TYPE,
+ DATA_TYPE,
+ JSON_MODEL
+ }
+
+ /**
+ * Instantiates a new ms model utils.
+ */
+ public MsModelUtils() {
+ // Default Constructor
+ }
+
+ /**
+ * Instantiates a new ms model utils.
+ *
+ * @param commonClassDao the common class dao
+ */
+ public MsModelUtils(CommonClassDao commonClassDao) {
+ MsModelUtils.commonClassDao = commonClassDao;
+ }
+
+ /**
+ * Instantiates a new ms model utils.
+ *
+ * @param onap the onap
+ * @param policy the policy
+ */
+ public MsModelUtils(String onap, String policy) {
+ this.onap = onap;
+ this.policy = policy;
+ }
+
+ /**
+ * Process epackage.
+ *
+ * @param file the file
+ * @param model the model
+ * @return the map
+ */
+ public Map<String, MsAttributeObject> processEpackage(String file, ModelType model) {
+ if (model == ModelType.XMI) {
+ processXmiEpackage(file);
+ }
+ return classMap;
+
+ }
+
+ /**
+ * Process XMI epackage.
+ *
+ * @param xmiFile the xmi file
+ */
+ 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();
+ }
+ }
+
+ /**
+ * Check for matching class.
+ */
+ 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);
+ }
+
+ }
+
+ /**
+ * Update matching.
+ *
+ * @param tempAttribute the temp attribute
+ * @param key the 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);
+ }
+
+ }
+ }
+
+ /**
+ * Adds the enum class map.
+ */
+ private void addEnumClassMap() {
+ for (Entry<String, MsAttributeObject> value : classMap.entrySet()) {
+ value.getValue().setEnumType(enumMap);
+ }
+ }
+
+ /**
+ * Gets the epackage.
+ *
+ * @param xmiFile the xmi file
+ * @return the epackage
+ */
+ private EPackage getEpackage(String xmiFile) {
+ ResourceSet resSet = new ResourceSetImpl();
+ Resource.Factory.Registry reg = Resource.Factory.Registry.INSTANCE;
+ Map<String, Object> objectMap = reg.getExtensionToFactoryMap();
+ objectMap.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);
+ }
+
+ /**
+ * Gets the e enum.
+ *
+ * @param obj the obj
+ * @return the e enum
+ */
+ 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 enumLiteral : eenum.getELiterals()) {
+ Enumerator instance = enumLiteral.getInstance();
+ String value = instance.getLiteral();
+ valueList.add(value);
+ }
+ returnMap.put(name, valueList.toString());
+ return returnMap;
+ }
+
+ /**
+ * Gets the attributes.
+ *
+ * @param className the class name
+ * @param dependency the dependency
+ * @param root the root
+ */
+ 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);
+ }
+
+ /**
+ * Gets the annotation.
+ *
+ * @param root the root
+ * @param className the class name
+ * @param extendClass the extend class
+ * @return the annotation
+ */
+ 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;
+ }
+
+ /**
+ * Find matching annotation.
+ *
+ * @param annotationSet the annotation set
+ * @param obj the obj
+ */
+ private void findMatchingAnnotation(HashMap<String, String> annotationSet, EObject obj) {
+ EStructuralFeature estrucClassifier = (EStructuralFeature) obj;
+ if (estrucClassifier.getEAnnotations().isEmpty()) {
+ return;
+ }
+ String matching = annotationValue(estrucClassifier, AnnotationType.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);
+ }
+ }
+
+ }
+
+ /**
+ * Check annotation.
+ *
+ * @param annotationSet the annotation set
+ * @param obj the obj
+ */
+ private void checkAnnotation(HashMap<String, String> annotationSet, EStructuralFeature obj) {
+ EStructuralFeature estrucClassifier = obj;
+ if (estrucClassifier.getEAnnotations().isEmpty()) {
+ return;
+ }
+ String matching = annotationValue(estrucClassifier, AnnotationType.MATCHING, policy);
+ if (matching != null) {
+ annotationSet.put(estrucClassifier.getName(), matching);
+ }
+ String range = annotationValue(estrucClassifier, AnnotationType.VALIDATION, policy);
+ if (range != null) {
+ annotationSet.put(estrucClassifier.getName(), range);
+ }
+ String annotationDict = annotationValue(estrucClassifier, AnnotationType.DICTIONARY, policy);
+ if (annotationDict != null) {
+ annotationSet.put(estrucClassifier.getName(), annotationDict);
+ }
+ }
+
+ /**
+ * Gets the sub attribute list.
+ *
+ * @param root the root
+ * @param className the class name
+ * @param superClass the super class
+ * @return the sub attribute list
+ */
+ 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;
+ }
+
+ /**
+ * Update sub attributes.
+ *
+ * @param subAttribute the sub attribute
+ * @param obj the obj
+ * @param estrucClassifier the e struc classifier
+ */
+ 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(E_PROXY_URI)) {
+ String required = REQUIREDFALSE;
+ if (estrucClassifier.getLowerBound() == 1) {
+ required = REQUIREDTRUE;
+ }
+ subAttribute.put(estrucClassifier.getName(), refType.getName() + required);
+ }
+ }
+ }
+
+ /**
+ * Check defult value.
+ *
+ * @param defultValue the defult value
+ * @return the string
+ */
+ public String checkDefultValue(String defultValue) {
+ if (defultValue != null) {
+ return DEFAULTVALUE + defultValue;
+ }
+ return ":defaultValue-NA";
+
+ }
+
+ /**
+ * Check required pattern.
+ *
+ * @param upper the upper
+ * @param lower the lower
+ * @return the string
+ */
+ public String checkRequiredPattern(int upper, int lower) {
+ String pattern = XACMLProperties.getProperty(XacmlRestProperties.PROP_XCORE_REQUIRED_PATTERN);
+ if (pattern != null && upper == Integer.parseInt(pattern.split(",")[1])
+ && lower == Integer.parseInt(pattern.split(",")[0])) {
+ return REQUIREDTRUE;
+ }
+ return REQUIREDFALSE;
+ }
+
+ /**
+ * Builds the java object.
+ *
+ * @param map the map
+ * @return the JSON object
+ */
+ public JSONObject buildJavaObject(Map<String, String> map) {
+ return new JSONObject(map);
+ }
+
+ /**
+ * Gets the ref attribute list.
+ *
+ * @param root the root
+ * @param className the class name
+ * @param superClass the super class
+ * @return the ref attribute list
+ */
+ 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;
+ }
+
+ /**
+ * Upd enum type ref attrib.
+ *
+ * @param refAttribute the ref attribute
+ * @param obj the obj
+ * @param estrucClassifier the e struc classifier
+ */
+ 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);
+ }
+
+ /**
+ * Upd ref attributes.
+ *
+ * @param refAttribute the ref attribute
+ * @param obj the obj
+ * @param estrucClassifier the e struc classifier
+ */
+ private void updRefAttributes(HashMap<String, String> refAttribute, EStructuralFeature obj,
+ EStructuralFeature estrucClassifier) {
+ EClass refType = ((EReference) obj).getEReferenceType();
+ if (refType.toString().contains(E_PROXY_URI)) {
+ String one = refType.toString().split(E_PROXY_URI)[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);
+ }
+ }
+
+ /**
+ * Annotation test.
+ *
+ * @param estrucClassifier the e struc classifier
+ * @param annotation the annotation
+ * @param type the type
+ * @return true, if successful
+ */
+ 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;
+ }
+
+ /**
+ * Annotation value.
+ *
+ * @param estrucClassifier the e struc classifier
+ * @param annotation the annotation
+ * @param type the type
+ * @return the string
+ */
+ private String annotationValue(EStructuralFeature estrucClassifier, AnnotationType 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 == AnnotationType.VALIDATION) {
+ return onapValue;
+ } else {
+ return onapType + "-" + onapValue;
+ }
+ }
+ }
+
+ return onapValue;
+ }
+
+ /**
+ * Checks if is required attribute.
+ *
+ * @param obj the obj
+ * @param className the class name
+ * @return true, if is required attribute
+ */
+ public boolean isRequiredAttribute(EObject obj, String className) {
+ EClassifier eclassifier = (EClassifier) obj;
+ String workingClass = eclassifier.getName().trim();
+ return workingClass.equalsIgnoreCase(className);
+ }
+
+ /**
+ * Checks if is policy template.
+ *
+ * @param root the root
+ * @param className the class name
+ * @return true, if is policy template
+ */
+ 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;
+ }
+
+ /**
+ * Check policy template.
+ *
+ * @param eclass the e class
+ * @return true, if successful
+ */
+ 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;
+ }
+
+ /**
+ * Gets the sub types.
+ *
+ * @param root the root
+ * @param className the class name
+ * @return the sub types
+ */
+ 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;
+ }
+
+ /**
+ * Find sub types.
+ *
+ * @param className the class name
+ * @param returnSubTypes the return sub types
+ * @param classifier the classifier
+ * @return the string
+ */
+ 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;
+ }
+
+ /**
+ * Gets the attribute list.
+ *
+ * @param root the root
+ * @param className the class name
+ * @param superClass the super class
+ * @return the attribute list
+ */
+ 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;
+
+ }
+
+ /**
+ * Check struc classifier.
+ *
+ * @param refAttribute the ref attribute
+ * @param obj the obj
+ * @param estrucClassifier the e struc classifier
+ */
+ 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);
+ }
+ }
+
+ /**
+ * Upd E reference attrib.
+ *
+ * @param refAttribute the ref attribute
+ * @param dictionaryTest the dictionary test
+ * @param obj the obj
+ * @param estrucClassifier the e struc classifier
+ */
+ private void updEReferenceAttrib(HashMap<String, String> refAttribute, boolean dictionaryTest,
+ EStructuralFeature obj, EStructuralFeature estrucClassifier) {
+ String etype;
+ String name = estrucClassifier.getName();
+ if (dictionaryTest) {
+ etype = annotationValue(estrucClassifier, AnnotationType.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);
+ }
+
+ /**
+ * Array check.
+ *
+ * @param upperBound the upper bound
+ * @return the string
+ */
+ public String arrayCheck(int upperBound) {
+
+ if (upperBound == -1) {
+ return MANYTRUE;
+ }
+
+ return MANYFALSE;
+ }
+
+ /**
+ * Gets the dependency list.
+ *
+ * @param eclassifier the e classifier
+ * @return the dependency list
+ */
+ 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(E_PROXY_URI)) {
+ String one = depend.toString().split(E_PROXY_URI)[1];
+ String value = StringUtils.replaceEach(one.split("#")[1], new String[]
+ { "//", ")" }, new String[]
+ { "", "" });
+ returnValue.add(value);
+ }
+ }
+
+ return returnValue;
+ }
+
+ /**
+ * Builds the sub list.
+ *
+ * @param subClassAttributes the sub class attributes
+ * @param classMap the class map
+ * @param className the class name
+ * @return the map
+ */
+ 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;
+ }
+
+ /**
+ * Recursive reference.
+ *
+ * @param classMap the class map
+ * @param className the class name
+ * @return the map
+ */
+ 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;
+
+ }
+
+ /**
+ * Creates the json.
+ *
+ * @param classMap the class map
+ * @param className the class name
+ * @return the string
+ */
+ 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);
+ }
+
+ /**
+ * Gets the refclass.
+ *
+ * @param classMap the class map
+ * @param className the class name
+ * @return the refclass
+ */
+ 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;
+ }
+
+ /**
+ * Creates the sub attributes.
+ *
+ * @param dependency the dependency
+ * @param classMap the class map
+ * @param modelName the model name
+ * @return the string
+ */
+ 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);
+ }
+
+ /**
+ * Gets the full dependency list.
+ *
+ * @param dependency the dependency
+ * @param classMap the class map
+ * @return the full dependency list
+ */
+ 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;
+ }
+
+ /**
+ * Upd dependency list.
+ *
+ * @param returnList the return list
+ * @param depend the depend
+ */
+ private void updDependencyList(ArrayList<String> returnList, String depend) {
+ if (!returnList.contains(depend) && !depend.isEmpty()) {
+ returnList.add(depend.trim());
+ }
+ }
+
+ /**
+ * Parses the TOSCA model.
+ *
+ * @param fileName the file name
+ * @return the string
+ */
+ public String parseTosca(String fileName) {
+ Map<String, String> map = new LinkedHashMap<>();
+ try {
+ map = load(fileName);
+ if (map != null && 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;
+ }
+
+ /**
+ * Load.
+ *
+ * @param fileName the file name
+ * @return the map
+ * @throws IOException Signals that an I/O exception has occurred.
+ * @throws ParserException the parser exception
+ */
+ public Map<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 = yaml.load(is);
+ } catch (FileNotFoundException e) {
+ logger.error(e);
+ } catch (Exception e) {
+ logger.error(e);
+ throw new ParserException("Invalid TOSCA Model format. Please make sure it is a valid YAML file");
+ }
+
+ 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);
+
+ if (!isDuplicatedAttributes && orderedElements != null && !orderedElements.isEmpty()) {
+ 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, new StringBuilder(), path, yamlMap);
+ return settings;
+ }
+
+ /**
+ * Validations.
+ *
+ * @param yamlMap the yaml map
+ * @return the string
+ */
+ @SuppressWarnings("unchecked")
+ private String validations(@SuppressWarnings("rawtypes") Map 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<Entry> entries = yamlMap.entrySet();
+ for (Map.Entry<Object, Object> me : entries) {
+ if (TOSCA_SIMPLE_YAML_1_0_0.equals(me.getValue())) {
+ isToscaVersionValueFound = true;
+ }
+
+ switch (me.getKey().toString()) {
+ case TOSCA_DEFINITION_VERSION:
+ isToscaVersionKeyFound = true;
+ order++;
+ m1.put(TOSCA_DEFINITION_VERSION, order);
+ break;
+ case NODE_TYPE:
+ isNoteTypeFound = true;
+ order++;
+ m1.put(NODE_TYPE, order);
+ break;
+ case DATA_TYPE:
+ isDataTypeFound = true;
+ order++;
+ m1.put(DATA_TYPE, order);
+ break;
+ case JSON_MODEL:
+ setJsonRuleFormation(me.getValue().toString());
+ break;
+ default:
+ break;
+ }
+ }
+ 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_DEFINITION_VERSION);
+
+ if (version > 1) {
+ return "tosca_definitions_version should be defined first.";
+ }
+
+ short data = (short) m1.get(DATA_TYPE);
+ short node = (short) m1.get(NODE_TYPE);
+ if (isDataTypeFound && node > data) {
+ return "node_types should be defined before data_types.";
+ }
+
+ }
+
+ return null;
+ }
+
+ /**
+ * Serialize map.
+ *
+ * @param settings the settings
+ * @param sb the sb
+ * @param path the path
+ * @param yamlMap the yaml map
+ */
+ @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());
+ }
+ }
+ }
+
+ /**
+ * Serialize list.
+ *
+ * @param settings the settings
+ * @param sb the sb
+ * @param path the path
+ * @param yamlList the yaml list
+ */
+ @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++;
+ }
+ }
+
+ /**
+ * Serialize value.
+ *
+ * @param settings the settings
+ * @param sb the sb
+ * @param path the path
+ * @param name the name
+ * @param value the value
+ */
+ 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());
+ }
+
+ /**
+ * Parses the data and policy nodes.
+ *
+ * @param map the map
+ */
+ void parseDataAndPolicyNodes(Map<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);
+ }
+ }
+ }
+
+ /**
+ * String between dots.
+ *
+ * @param str the str
+ * @return the int
+ */
+ // 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();
+ }
+
+ /**
+ * String between dots for data fields.
+ *
+ * @param str the str
+ */
+ 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]);
+ }
+ }
+ }
+
+ /**
+ * Construct json for data fields.
+ *
+ * @param dataMapForJson the data map for json
+ */
+ 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 keyString = entry.getKey();
+ json = new JSONObject();
+ HashMap<String, String> jsonHm = dataMapKey.get(keyString);
+ for (Map.Entry<String, String> entryMap : jsonHm.entrySet()) {
+ String key = entryMap.getKey();
+ json.put(key, jsonHm.get(key));
+ }
+ mainObject.put(keyString, 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("###############################################################################");
+ }
+
+ /**
+ * Parses the data nodes.
+ *
+ * @param map the map
+ * @return the linked hash map
+ */
+ LinkedHashMap<String, String> parseDataNodes(Map<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 ("true".equalsIgnoreCase(matchableValue)) {
+ String key = uniqueDataKeySplit[uniqueDataKeySplit.length - 1];
+ matchableValues.put(key, MATCHINGTRUE);
+ }
+
+ if (requiredValue == null || requiredValue.isEmpty()) {
+ requiredValue = "false";
+ }
+ if (INTEGER.equalsIgnoreCase(typeValue) || STRING.equalsIgnoreCase(typeValue)
+ || typeValue.equalsIgnoreCase(BOOLEAN)) {
+ 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);
+
+ String findDescription = DATATYPE + uniqueDataKeySplit[0] + PROPERTIES + uniqueDataKeySplit[1]
+ + DESCRIPTION;
+ attributeIndividualStringBuilder.append(DESCRIPTION_TOKEN + map.get(findDescription));
+ 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 findDefaultValue = DATATYPE + uniqueDataKeySplit[0] + PROPERTIES + uniqueDataKeySplit[1]
+ + ".entry_schema.default";
+ String findDescription = DATATYPE + uniqueDataKeySplit[0] + PROPERTIES + uniqueDataKeySplit[1]
+ + ".entry_schema.description";
+ String listValue = map.get(findList);
+ String defaultValue = map.get(findDefaultValue);
+ String description = map.get(findDescription);
+ 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);
+ referenceIndividualStringBuilder.append(DESCRIPTION_TOKEN + description);
+ dataMapForJson.put(uniqueDataKey, referenceIndividualStringBuilder.toString());
+ } else { // Its string
+ StringBuilder stringListItems = new StringBuilder();
+ if (LIST.equalsIgnoreCase(typeValue)) {
+ stringListItems.append(uniqueDataKeySplit[1].toUpperCase() + DEFAULTVALUE + defaultValue
+ + REQUIREDVALUE + requiredValue + MANYFALSE + DESCRIPTION_TOKEN
+ + description);
+ } else if (MAP.equalsIgnoreCase(typeValue)) {
+ stringListItems.append(uniqueDataKeySplit[1].toUpperCase() + DEFAULTVALUE + defaultValue
+ + REQUIREDVALUE + requiredValue + MANYTRUE + DESCRIPTION_TOKEN
+ + description);
+ }
+ dataMapForJson.put(uniqueDataKey, stringListItems.toString());
+ dataListBuffer.append(uniqueDataKeySplit[1].toUpperCase() + "=[");
+ for (int i = 0; i < 10; i++) {
+ String findConstraints = DATATYPE + uniqueDataKeySplit[0] + PROPERTIES
+ + uniqueDataKeySplit[1] + ".entry_schema.constraints.0.valid_values."
+ + i;
+ String constraintsValue = map.get(findConstraints);
+ logger.info(constraintsValue);
+ boolean ruleCheck = false;
+ if (constraintsValue == null) {
+ break;
+ } else if (constraintsValue.startsWith(DICTIONARY)) {
+ List<Object> dictFromDB = null;
+ String[] dictionaryNameValRule;
+ String[] dictionaryName = constraintsValue.split(":");
+ String dictionaryNameVal = dictionaryName[1];
+ if (dictionaryNameVal.contains("#Rules")) {
+ ruleCheck = true;
+ dictionaryNameValRule = dictionaryNameVal.split("#");
+ dictFromDB = commonClassDao.getDataById(DictionaryData.class, DICTIONARYNAME,
+ dictionaryNameValRule[0]);
+ } else {
+ dictFromDB = commonClassDao.getDataById(DictionaryData.class, DICTIONARYNAME,
+ dictionaryName[1]);
+ }
+ if (dictFromDB != null && !dictFromDB.isEmpty()) {
+ DictionaryData data = (DictionaryData) dictFromDB.get(0);
+ if (ruleCheck) {
+ constraintsValue = DICTIONARY + data.getDictionaryUrl() + "@"
+ + data.getDictionaryDataByName() + "&Rule";
+ } else {
+ constraintsValue = DICTIONARY + data.getDictionaryUrl() + "@"
+ + data.getDictionaryDataByName();
+ }
+ }
+ dataListBuffer.append(constraintsValue + ",");
+ } else {
+ logger.info("constraintsValue => " + constraintsValue);
+ if (constraintsValue.contains("=")) {
+ constraintsValue = constraintsValue.replace("=", "equal-sign");
+ }
+ dataConstraints.add(constraintsValue);
+ dataListBuffer.append(constraintsValue + ",");
+ }
+ }
+ dataListBuffer.append("]#");
+ logger.info(dataListBuffer);
+ }
+ }
+ } else {
+ String findUserDefined = DATATYPE + uniqueDataKeySplit[0] + "." + PROPERTIES_KEY + "."
+ + uniqueDataKeySplit[1] + TYPE;
+ String findDescription = DATATYPE + uniqueDataKeySplit[0] + "." + PROPERTIES_KEY + "."
+ + uniqueDataKeySplit[1] + DESCRIPTION;
+ String userDefinedValue = map.get(findUserDefined);
+ String description = map.get(findDescription);
+ String trimValue = userDefinedValue.substring(userDefinedValue.lastIndexOf('.') + 1);
+ StringBuilder referenceIndividualStringBuilder = new StringBuilder();
+ referenceIndividualStringBuilder.append(trimValue + REQUIREDVALUE);
+ referenceIndividualStringBuilder.append(requiredValue + MANYFALSE);
+ referenceIndividualStringBuilder.append(DESCRIPTION_TOKEN + description);
+ dataMapForJson.put(uniqueDataKey, referenceIndividualStringBuilder.toString());
+
+ }
+ } else {
+ matchableValues.put(uniqueDataKey, MATCHINGTRUE);
+ }
+ }
+
+ return dataMapForJson;
+ }
+
+ /**
+ * Parses the policy nodes.
+ *
+ * @param map the map
+ * @return the linked hash map
+ * @throws ParserException the parser exception
+ */
+ 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 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 (("type").equals(keyStr)) {
+ if (!key.contains("entry_schema")) {
+ hm.put(keyStr, valueStr);
+ }
+ } else {
+ hm.put(keyStr, valueStr);
+ }
+ mapKey.put(uniqueKey, hm);
+ }
+ }
+ }
+ }
+ return mapKey;
+ }
+
+ /**
+ * Creates the attributes.
+ *
+ * @param mapKey the map key
+ */
+ private 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 (keyValues.get("type") != null && (STRING.equalsIgnoreCase(keyValues.get("type"))
+ || INTEGER.equalsIgnoreCase(keyValues.get("type"))
+ || BOOLEAN.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);
+ attributeIndividualStringBuilder.append(DESCRIPTION_TOKEN + keyValues.get(DESCRIPTION_KEY));
+ attributeStringBuilder.append(attributeIndividualStringBuilder + ",");
+ if (keyValues.get(MATCHABLEKEY) != null && "true".equalsIgnoreCase(keyValues.get(MATCHABLEKEY))) {
+ matchableValues.put(keySetString, MATCHINGTRUE);
+ }
+ } else if (LIST.equalsIgnoreCase(keyValues.get("type"))) {
+ if ("true".equalsIgnoreCase(keyValues.get(MATCHABLEKEY))) {
+ matchableValues.put(keySetString, MATCHINGTRUE);
+ }
+ // List Data type
+ 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
+ + DESCRIPTION_TOKEN + keyValues.get(DESCRIPTION_KEY));
+ referenceStringBuilder.append(referenceIndividualStringBuilder + ",");
+ isDefinedType = true;
+ }
+ }
+
+ }
+
+ if (!isDefinedType && LIST.equalsIgnoreCase(keyValues.get("type"))
+ && (constraints == null || constraints.isEmpty())) {
+ referenceStringBuilder.append(keySetString + "=MANY-true" + ",");
+ }
+ } else {
+ // User defined Datatype.
+ if ("true".equalsIgnoreCase(keyValues.get(MATCHABLEKEY))) {
+ 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
+ + DESCRIPTION_TOKEN + keyValues.get(DESCRIPTION_KEY));
+ 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) {
+ if (str.contains(DICTIONARY)) {
+ String[] dictionaryName = str.split(":");
+ List<Object> dictFromDB = commonClassDao.getDataById(DictionaryData.class, DICTIONARYNAME,
+ dictionaryName[1]);
+ if (dictFromDB != null && !dictFromDB.isEmpty()) {
+ DictionaryData data = (DictionaryData) dictFromDB.get(0);
+ str = DICTIONARY + data.getDictionaryUrl() + "@" + data.getDictionaryDataByName();
+ }
+ }
+ 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();
+ }
+
+ /**
+ * Find node.
+ *
+ * @param map the map
+ */
+ @SuppressWarnings("unchecked")
+ private 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_KEY) && value instanceof Map) {
+ saveNodes((LinkedHashMap<?, ?>) value);
+ if (isDuplicatedAttributes) {
+ orderedElements = new ArrayList<>();
+ return;
+ }
+ }
+
+ if (!"policy.nodes.Root".equals(key) && value instanceof Map) {
+ // value is a Map object, then make a recursive call
+ findNode((LinkedHashMap<Object, Object>) value);
+ }
+ });
+
+ }
+
+ /**
+ * Save nodes.
+ *
+ * @param map the map
+ */
+ private void saveNodes(LinkedHashMap<?, ?> map) {
+
+ for (Entry<?, ?> entry : map.entrySet()) {
+
+ if (orderedElements.indexOf(entry.getKey()) >= 0) { // duplicated attribute names
+ isDuplicatedAttributes = true;
+ return;
+ } else {
+ orderedElements.add((String) entry.getKey());
+ }
+ }
+ }
+}
Code Review / policy / engine.git / blobdiff