Merge "TOSCA model enhancements"

1 files changed, 415 insertions, 369 deletions

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 50628d7d5..411ecaa26 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
@@ -23,11 +23,40 @@ 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 org.apache.commons.lang.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-import org.eclipse.emf.common.util.*;
-import org.eclipse.emf.ecore.*;
+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;
@@ -38,16 +67,12 @@ import org.json.JSONObject;
 import org.onap.policy.rest.XACMLRestProperties;
 import org.yaml.snakeyaml.Yaml;
 
-import java.io.*;
-import java.util.*;
-import java.util.Map.Entry;
-
 
 public class MSModelUtils {
 
-    private static final Log logger	= LogFactory.getLog(MSModelUtils.class);
+    private static final Log logger = LogFactory.getLog(MSModelUtils.class);
 
-    private HashMap<String,MSAttributeObject > classMap = new HashMap<>();
+    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";
@@ -56,45 +81,54 @@ public class MSModelUtils {
     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 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 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 Map<String, String> matchableValues;
+    private static final String PROPERTIES = ".properties.";
+    private static final String DATATYPE = "data_types.policy.data.";
+    private static final String TYPE = ".type";
+    private 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 BOOLEAN = "boolean";
+    private static final String LIST = "list";
+    private static final String MAP = "map";
+    private static final String DEFAULT = ".default";
+    private static final String MANYFALSE = ":MANY-false";
+    private static final String DESCRIPTION = ".description";
+
+    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 static final String DESCRIPTION_KEY = "description";  
+    private static final String DESCRIPTION_TOKEN =":description-";
+    private static final String PROPERTIES_KEY = "properties";
+    private static final String DATA_TYPE = "data_types";
+    private static final String ERROR = "error";
+    private static final String NODE_TYPE = "node_types";
+    private static final String TOSCA_DEFINITION_VERSION = "tosca_definitions_version";
+    private StringBuilder dataListBuffer = new StringBuilder();
+    private List<String> dataConstraints = new ArrayList<>();
     private String attributeString = null;
+    private boolean isDuplicatedAttributes = false;
 
-    public MSModelUtils(){
-    }
+    public MSModelUtils() {}
 
-    public MSModelUtils(String onap, String policy){
+    public MSModelUtils(String onap, String policy) {
         this.onap = onap;
         this.policy = policy;
     }
 
-    private enum ANNOTATION_TYPE{
+    private enum ANNOTATION_TYPE {
         MATCHING, VALIDATION, DICTIONARY
     };
 
@@ -103,8 +137,8 @@ public class MSModelUtils {
     };
 
 
-    public Map<String, MSAttributeObject> processEpackage(String file, MODEL_TYPE model){
-        if (model == MODEL_TYPE.XMI ){
+    public Map<String, MSAttributeObject> processEpackage(String file, MODEL_TYPE model) {
+        if (model == MODEL_TYPE.XMI) {
             processXMIEpackage(file);
         }
         return classMap;
@@ -742,31 +776,22 @@ public class MSModelUtils {
     /*
      * 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");
-                }
+            map = load(fileName);
+            if (map != null && map.get(ERROR) != null) {
+                return map.get(ERROR);
             }
-
             parseDataAndPolicyNodes(map);
-
-            LinkedHashMap<String,String> dataMapForJson=parseDataNodes(map);
-
+            LinkedHashMap<String, String> dataMapForJson = parseDataNodes(map);
             constructJsonForDataFields(dataMapForJson);
-
-            LinkedHashMap<String,LinkedHashMap<String,String>> mapKey= parsePolicyNodes(map);
-
+            LinkedHashMap<String, LinkedHashMap<String, String>> mapKey = parsePolicyNodes(map);
             createAttributes(mapKey);
 
         } catch (IOException e) {
             logger.error(e);
-        }catch(ParserException e){
+        } catch (ParserException e) {
             logger.error(e);
             return e.getMessage();
         }
@@ -775,16 +800,16 @@ public class MSModelUtils {
     }
 
     @SuppressWarnings("unchecked")
-    public LinkedHashMap<String, String> load(String fileName) throws IOException,ParserException {
+    public LinkedHashMap<String, String> load(String fileName) throws IOException, ParserException {
         File newConfiguration = new File(fileName);
-        StringBuilder orderInfo = new StringBuilder("[");
+        StringBuffer orderInfo = new StringBuffer("[");
         Yaml yaml = new Yaml();
         LinkedHashMap<Object, Object> yamlMap = null;
-        try(InputStream is = new FileInputStream(newConfiguration)){
+        try (InputStream is = new FileInputStream(newConfiguration)) {
             yamlMap = (LinkedHashMap<Object, Object>) yaml.load(is);
         } catch (FileNotFoundException e) {
             logger.error(e);
-        }catch(Exception e){
+        } catch (Exception e) {
             throw new ParserException("Invalid TOSCA Model format. Please make sure it is a valid YAML file");
         }
 
@@ -796,33 +821,35 @@ public class MSModelUtils {
 
         String message = validations(yamlMap);
 
-        if(message != null){
-            settings.put("error", message);
+        if (message != null) {
+            settings.put(ERROR, message);
             return settings;
         }
 
         findNode(yamlMap);
 
-        orderedElements.stream().forEach((string) -> {
-            orderInfo.append(string);
-            orderInfo.append(",");
-            logger.info("Content: " + string);
-        });
+        if (!isDuplicatedAttributes && orderedElements != null && orderedElements.size() > 0) {
+            orderedElements.stream().forEach((string) -> {
+                orderInfo.append(string);
+                orderInfo.append(",");
+                logger.info("Content: " + string);
+            });
 
-        orderInfo.append("]");
+            orderInfo.append("]");
 
-        dataOrderInfo = orderInfo.toString();
-        dataOrderInfo = dataOrderInfo.replace(",]", "]");
+            dataOrderInfo = orderInfo.toString();
+            dataOrderInfo = dataOrderInfo.replace(",]", "]");
 
-        logger.info("dataOrderInfo :" + dataOrderInfo);
+            logger.info("dataOrderInfo :" + dataOrderInfo);
+        }
 
-        List<String> path = new ArrayList <>();
+        List<String> path = new ArrayList<>();
         serializeMap(settings, sb, path, yamlMap);
         return settings;
     }
 
     @SuppressWarnings("unchecked")
-    private String validations(@SuppressWarnings("rawtypes") LinkedHashMap yamlMap){
+    private String validations(@SuppressWarnings("rawtypes") LinkedHashMap yamlMap) {
 
         boolean isNoteTypeFound = false;
         boolean isDataTypeFound = false;
@@ -830,76 +857,72 @@ public class MSModelUtils {
         boolean isToscaVersionValueFound = false;
         @SuppressWarnings("rawtypes")
         Map m1 = new HashMap();
-        short order =0;
-        if(yamlMap != null){
+        short order = 0;
+        if (yamlMap != null) {
             // Get a set of the entries
-             @SuppressWarnings("rawtypes")
+            @SuppressWarnings("rawtypes")
             Set set = yamlMap.entrySet();
-             // Get an iterator
-             @SuppressWarnings("rawtypes")
+            // 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);
-                 }
+            // Display elements
+            while (i.hasNext()) {
+                @SuppressWarnings("rawtypes")
+                Map.Entry me = (Map.Entry) i.next();
+
+                if (TOSCA_DEFINITION_VERSION.equals(me.getKey())) {
+                    isToscaVersionKeyFound = true;
+                    order++;
+                    m1.put(TOSCA_DEFINITION_VERSION, order);
+                }
 
-                 if("data_types".equals(me.getKey())){
-                     isDataTypeFound = true;
-                     order++;
-                     m1.put("data_types", order);
-                 }
+                if ("tosca_simple_yaml_1_0_0".equals(me.getValue())) {
+                    isToscaVersionValueFound = true;
+                }
 
-             }
+                if (NODE_TYPE.equals(me.getKey())) {
+                    isNoteTypeFound = true;
+                    order++;
+                    m1.put(NODE_TYPE, order);
+                }
 
+                if (DATA_TYPE.equals(me.getKey())) {
+                    isDataTypeFound = true;
+                    order++;
+                    m1.put(DATA_TYPE, order);
+                }
 
-             if(!isDataTypeFound){
-                 return "data_types are missing or invalid.";
-             }
+            }
 
-             if(!isToscaVersionKeyFound || !isToscaVersionValueFound){
-                 return "tosca_definitions_version is missing or invalid.";
-             }
+            if (!isToscaVersionKeyFound || !isToscaVersionValueFound) {
+                return "tosca_definitions_version is missing or invalid.";
+            }
 
-             if(!isNoteTypeFound){
-                 return "node_types are missing or invalid.";
-             }
+            if (!isNoteTypeFound) {
+                return "node_types are missing or invalid.";
+            }
 
-             short version = (short) m1.get("tosca_definitions_version");
+            short version = (short) m1.get(TOSCA_DEFINITION_VERSION);
 
-             if(version > 1 ){
+            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){
+            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;
     }
 
-    @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()) {
+    @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());
@@ -916,7 +939,8 @@ public class MSModelUtils {
     }
 
     @SuppressWarnings("unchecked")
-    private void serializeList(LinkedHashMap<String, String> settings, StringBuilder sb, List<String> path, List<String> yamlList) {
+    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) {
@@ -934,7 +958,8 @@ public class MSModelUtils {
         }
     }
 
-    private void serializeValue(LinkedHashMap<String, String> settings, StringBuilder sb, List<String> path, String name, Object value) {
+    private void serializeValue(LinkedHashMap<String, String> settings, StringBuilder sb, List<String> path,
+            String name, Object value) {
         if (value == null) {
             return;
         }
@@ -947,23 +972,20 @@ public class MSModelUtils {
     }
 
 
-    void parseDataAndPolicyNodes(LinkedHashMap<String,String> map){
-        for(String key:map.keySet()){
-            if(key.contains("policy.nodes.Root"))
-            {
+    void parseDataAndPolicyNodes(LinkedHashMap<String, String> map) {
+        for (String key : map.keySet()) {
+            if (key.contains("policy.nodes.Root")) {
                 continue;
-            }
-            else if(key.contains("policy.nodes")){
+            } else if (key.contains("policy.nodes")) {
                 String wordToFind = "policy.nodes.";
-                int indexForPolicyNode=key.indexOf(wordToFind);
-                String subNodeString= key.substring(indexForPolicyNode+13, key.length());
+                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());
+            } 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);
             }
@@ -971,12 +993,12 @@ public class MSModelUtils {
     }
 
     // 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){
+    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]);
             }
         }
@@ -985,51 +1007,50 @@ public class MSModelUtils {
     }
 
 
-    public void stringBetweenDotsForDataFields(String str){
-        String stringToSearch=str;
-        String[]ss=stringToSearch.split("\\.");
-        if(ss!=null){
-            int len= ss.length;
+    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]);
+            if (len > 2) {
+                uniqueDataKeys.add(ss[0] + "%" + ss[2]);
             }
         }
     }
 
-    void constructJsonForDataFields(LinkedHashMap<String,String> dataMapForJson){
-        LinkedHashMap<String,LinkedHashMap<String,String>> dataMapKey= new LinkedHashMap <>();
+    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])){
+        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 <>();
+            } else {
+                hmSub = new LinkedHashMap<>();
                 hmSub.put(uniqueDataKeySplit[1], value);
             }
 
             dataMapKey.put(uniqueDataKeySplit[0], hmSub);
         }
 
-        JSONObject mainObject= new JSONObject();
+        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();
+        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);
+            mainObject.put(s, json);
         }
         Iterator<String> keysItr = mainObject.keys();
-        while(keysItr.hasNext()) {
+        while (keysItr.hasNext()) {
             String key = keysItr.next();
             String value = mainObject.get(key).toString();
             retmap.put(key, value);
@@ -1039,166 +1060,175 @@ public class MSModelUtils {
         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);
+
+    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 findRequired = DATATYPE + uniqueDataKeySplit[0] + PROPERTIES + uniqueDataKeySplit[1] + REQUIRED;
+                String requiredValue = map.get(findRequired);
 
-                String matchable =DATATYPE+uniqueDataKeySplit[0]+PROPERTIES+uniqueDataKeySplit[1]+MATCHABLE;
+                String matchable = DATATYPE + uniqueDataKeySplit[0] + PROPERTIES + uniqueDataKeySplit[1] + MATCHABLE;
 
-                String matchableValue= map.get(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 ("true".equalsIgnoreCase(matchableValue)) {
+                    String key = uniqueDataKeySplit[uniqueDataKeySplit.length - 1];
+                    matchableValues.put(key, MATCHINGTRUE);
                 }
 
-                if(requiredValue == null || requiredValue.isEmpty()){
+                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);
+                if (INTEGER.equalsIgnoreCase(typeValue) || STRING.equalsIgnoreCase(typeValue)
+                        || typeValue.equalsIgnoreCase(BOOLEAN)) {
+                    String findDefault =
+                            DATATYPE + uniqueDataKeySplit[0] + PROPERTIES + uniqueDataKeySplit[1] + DEFAULT;
+                    String findDescription =
+                            DATATYPE + uniqueDataKeySplit[0] + PROPERTIES + uniqueDataKeySplit[1] + DESCRIPTION;
+                    String defaultValue = map.get(findDefault);
+                    String descriptionDefined = map.get(findDescription);
+                    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);
+                    attributeIndividualStringBuilder.append(DESCRIPTION_TOKEN + descriptionDefined);
                     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);
+                } 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());
-                        }//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);
+                        } 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());
-                            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);
+                            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);
+                                if (constraintsValue == null) {
                                     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("=")) {
+                                } else {
+                                    System.out.println("constraintsValue => " + constraintsValue);
+                                    if (constraintsValue.contains("=")) {
                                         constraintsValue = constraintsValue.replace("=", "equal-sign");
                                     }
-
                                     dataConstraints.add(constraintsValue);
-                                    dataListBuffer.append(constraintsValue+",");
+                                    dataListBuffer.append(constraintsValue + ",");
                                 }
                             }
-                            if(isConstraintsFound){
-                                dataListBuffer.append("]#");
-                            }
+                            dataListBuffer.append("]#");
+                            logger.info(dataListBuffer);
                         }
-                    }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);
+                } 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 requiredValue = map.get(required);
+                    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;
     }
 
+    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;
 
-    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)){
+            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 );
+                        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);
+                        if ("type".equals(keyStr)) {
+                            if (!key.contains("entry_schema")) {
+                                hm.put(keyStr, valueStr);
                             }
-                        }else{
-                            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.")){
+                        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);
+                        if (("type").equals(keyStr)) {
+                            if (!key.contains("entry_schema")) {
+                                hm.put(keyStr, valueStr);
                             }
-                        }else{
-                            hm.put(keyStr,valueStr);
+                        } else {
+                            hm.put(keyStr, valueStr);
                         }
                         mapKey.put(uniqueKey, hm);
                     }
@@ -1208,92 +1238,94 @@ public class MSModelUtils {
         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))){
+    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 && keyValues.get("type").equalsIgnoreCase(STRING)
+                    || keyValues.get("type") != null && keyValues.get("type").equalsIgnoreCase(INTEGER)
+                    || keyValues.get("type") != null && keyValues.get("type").equalsIgnoreCase(BOOLEAN)) {
+                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 && keyValues.get(MATCHABLEKEY).equalsIgnoreCase("true")) {
                     matchableValues.put(keySetString, MATCHINGTRUE);
                 }
-            }
-            else if(LIST.equalsIgnoreCase(keyValues.get("type"))){
+            } else if (LIST.equalsIgnoreCase(keyValues.get("type"))) {
 
-                if(("true").equalsIgnoreCase(keyValues.get(MATCHABLEKEY))){
+                if ("true".equalsIgnoreCase(keyValues.get(MATCHABLEKEY))) {
                     matchableValues.put(keySetString, MATCHINGTRUE);
                 }
-                //List Datatype
-                Set<String> keys= keyValues.keySet();
-                Iterator<String> itr=keys.iterator();
+                // 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
+                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+",");
+                        } 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"))){ //type is not user defined and is a list but no constraints defined.
-                    if(constraints == null || constraints.isEmpty()){
-                        referenceStringBuilder.append(keySetString+"=MANY-true"+",");
+                if (!isDefinedType && LIST.equalsIgnoreCase(keyValues.get("type"))) { 
+                    if (constraints == null || constraints.isEmpty()) {
+                        referenceStringBuilder.append(keySetString + "=MANY-true" + ",");
                     }
                 }
-            }else{
-                //User defined Datatype.
-                if("true".equalsIgnoreCase(keyValues.get(MATCHABLEKEY))){
+            } 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);
-                    referenceStringBuilder.append(referenceIndividualStringBuilder+",");
-                }else{
+                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){
-                    listBuffer.append(str+",");
+            if (constraints != null && constraints.isEmpty() == false) {
+                // 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+",");
+                StringBuilder referenceIndividualStringBuilder = new StringBuilder();
+                referenceIndividualStringBuilder.append(keySetString + "=" + keySetString.toUpperCase() + MANYFALSE);
+                referenceStringBuilder.append(referenceIndividualStringBuilder + ",");
                 constraints.clear();
             }
         }
@@ -1302,47 +1334,57 @@ public class MSModelUtils {
 
 
         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("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();
+        this.listConstraints = dataListBuffer.toString();
+        this.referenceAttributes = referenceStringBuilder.toString();
+        this.attributeString = attributeStringBuilder.toString();
     }
 
     @SuppressWarnings("unchecked")
-    public void findNode(LinkedHashMap<Object, Object> map) {
+    private void findNode(LinkedHashMap<Object, Object> map) {
 
-        map.forEach((key,value) -> {
+        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(PROPERTIES_KEY) && value instanceof Map) {
+                saveNodes((LinkedHashMap<?, ?>) value);
+                if (isDuplicatedAttributes) {
+                    orderedElements = new ArrayList<String>();
+                    return;
+                }
             }
 
-            if(!key.equals("policy.nodes.Root") && value instanceof Map){
-                //value is a Map object, then make a recursive call
-                findNode((LinkedHashMap<Object, Object>) value);
+            if (!key.equals("policy.nodes.Root")) {
+                // value is a Map object, then make a recursive call
+                if (value instanceof Map) {
+                    findNode((LinkedHashMap<Object, Object>) value);
+                }
             }
         });
 
     }
 
-    public void saveNodes(LinkedHashMap<?, ?> map) {
-
-        map.forEach((key,value) -> {
+    private void saveNodes(LinkedHashMap<?, ?> map) {
 
-            orderedElements.add((String)key);
-
-        });
+        for (Entry<?, ?> entry : map.entrySet()) {
 
+            if (orderedElements.indexOf((String) entry.getKey()) >= 0) { // duplicated attribute names
+                isDuplicatedAttributes = true;
+                return;
+            } else {
+                orderedElements.add((String) entry.getKey());
+            }
+        }
     }
 
     public String getAttributeString() {
         return attributeString;
     }
+
     public void setAttributeString(String attributeString) {
         this.attributeString = attributeString;
     }
@@ -1354,6 +1396,7 @@ public class MSModelUtils {
     public void setRetmap(LinkedHashMap<String, Object> retmap) {
         this.retmap = retmap;
     }
+
     public Map<String, String> getMatchableValues() {
         return matchableValues;
     }
@@ -1361,6 +1404,7 @@ public class MSModelUtils {
     public void setMatchableValues(Map<String, String> matchableValues) {
         this.matchableValues = matchableValues;
     }
+
     public String getReferenceAttributes() {
         return referenceAttributes;
     }
@@ -1368,6 +1412,7 @@ public class MSModelUtils {
     public void setReferenceAttributes(String referenceAttributes) {
         this.referenceAttributes = referenceAttributes;
     }
+
     public String getListConstraints() {
         return listConstraints;
     }
@@ -1375,6 +1420,7 @@ public class MSModelUtils {
     public void setListConstraints(String listConstraints) {
         this.listConstraints = listConstraints;
     }
+
     public String getDataOrderInfo() {
         return dataOrderInfo;
     }
@@ -1383,4 +1429,4 @@ public class MSModelUtils {
         this.dataOrderInfo = dataOrderInfo;
     }
 
-}
\ No newline at end of file
+}