2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2018 AT&T Intellectual Property. All rights
7 * ================================================================================
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 * ============LICENSE_END============================================
20 * ===================================================================
24 package org.onap.clamp.clds.tosca;
26 import java.util.ArrayList;
27 import java.util.HashMap;
28 import java.util.Iterator;
29 import java.util.LinkedHashMap;
30 import java.util.List;
33 import org.json.JSONArray;
34 import org.json.JSONObject;
35 import org.yaml.snakeyaml.Yaml;
38 * Tosca Model Yaml parser and convertor to JSON Schema consumable for JSON
42 public class ToscaYamlToJsonConvertor {
44 private int simpleTypeOrder = 1000;
45 private int complexTypeOrder = 10000;
46 private int complexSimpleTypeOrder = 1;
48 private int incrementSimpleTypeOrder() {
49 return simpleTypeOrder++;
52 private int incrementComplexTypeOrder() {
53 return complexTypeOrder = complexTypeOrder + 10000;
56 private int incrementComplexSimpleTypeOrder() {
57 complexSimpleTypeOrder++;
58 return complexTypeOrder + complexSimpleTypeOrder;
62 * Parses Tosca YAML string.
64 * @param yamlString YAML string
65 * @param modelTypeToUse The model type that must be used to obtain the Json
69 public String parseToscaYaml(String yamlString, String modelTypeToUse) {
71 Yaml yaml = new Yaml();
72 LinkedHashMap<String, Object> loadedYaml = yaml.load(yamlString);
73 if (loadedYaml == null) {
76 LinkedHashMap<String, Object> nodeTypes = new LinkedHashMap<>();
77 LinkedHashMap<String, Object> dataNodes = new LinkedHashMap<>();
78 JSONObject jsonParentObject = new JSONObject();
79 JSONObject jsonTempObject = new JSONObject();
80 parseNodeAndDataType(loadedYaml, nodeTypes, dataNodes);
81 populateJsonEditorObject(loadedYaml, nodeTypes, dataNodes, jsonParentObject, jsonTempObject, modelTypeToUse);
82 if (jsonTempObject.length() > 0) {
83 jsonParentObject = jsonTempObject;
85 JSONObject jsonEditorObject = new JSONObject();
86 jsonEditorObject.put(JsonEditorSchemaConstants.SCHEMA, jsonParentObject);
87 return jsonEditorObject.toString();
90 // Parse node_type and data_type
91 @SuppressWarnings("unchecked")
92 private void parseNodeAndDataType(LinkedHashMap<String, Object> map, LinkedHashMap<String, Object> nodeTypes,
93 LinkedHashMap<String, Object> dataNodes) {
94 map.entrySet().stream().forEach(n -> {
95 if (n.getKey().contains(ToscaSchemaConstants.NODE_TYPES) && n.getValue() instanceof Map) {
96 parseNodeAndDataType((LinkedHashMap<String, Object>) n.getValue(), nodeTypes, dataNodes);
97 } else if (n.getKey().contains(ToscaSchemaConstants.DATA_TYPES) && n.getValue() instanceof Map) {
98 parseNodeAndDataType((LinkedHashMap<String, Object>) n.getValue(), nodeTypes, dataNodes);
99 } else if (n.getKey().contains(ToscaSchemaConstants.POLICY_NODE)) {
100 nodeTypes.put(n.getKey(), n.getValue());
101 } else if (n.getKey().contains(ToscaSchemaConstants.POLICY_DATA)) {
102 dataNodes.put(n.getKey(), n.getValue());
107 @SuppressWarnings("unchecked")
108 private void populateJsonEditorObject(LinkedHashMap<String, Object> map, LinkedHashMap<String, Object> nodeTypes,
109 LinkedHashMap<String, Object> dataNodes, JSONObject jsonParentObject, JSONObject jsonTempObject,
110 String modelTypeToUse) {
112 Map<String, JSONObject> jsonEntrySchema = new HashMap<>();
113 jsonParentObject.put(JsonEditorSchemaConstants.TYPE, JsonEditorSchemaConstants.TYPE_OBJECT);
114 if (nodeTypes.get(modelTypeToUse) instanceof Map) {
115 ((LinkedHashMap<String, Object>) nodeTypes.get(modelTypeToUse)).entrySet().forEach(ntElement -> {
116 if (ntElement.getKey().equalsIgnoreCase(ToscaSchemaConstants.PROPERTIES)) {
117 JSONArray rootNodeArray = new JSONArray();
118 if (ntElement.getValue() instanceof Map) {
119 ((LinkedHashMap<String, Object>) ntElement.getValue()).entrySet()
120 .forEach((ntPropertiesElement) -> {
121 boolean isListNode = false;
122 parseDescription((LinkedHashMap<String, Object>) ntPropertiesElement.getValue(),
124 LinkedHashMap<String, Object> parentPropertiesMap = (LinkedHashMap<String, Object>) ntPropertiesElement
126 if (parentPropertiesMap.containsKey(ToscaSchemaConstants.TYPE)
127 && ((String) parentPropertiesMap.get(ToscaSchemaConstants.TYPE))
128 .contains(ToscaSchemaConstants.TYPE_MAP)
129 && parentPropertiesMap.containsKey(ToscaSchemaConstants.ENTRY_SCHEMA)) {
130 parentPropertiesMap = (LinkedHashMap<String, Object>) parentPropertiesMap
131 .get(ToscaSchemaConstants.ENTRY_SCHEMA);
134 if (parentPropertiesMap.containsKey(ToscaSchemaConstants.TYPE)
135 && ((String) parentPropertiesMap.get(ToscaSchemaConstants.TYPE))
136 .contains(ToscaSchemaConstants.POLICY_DATA)) {
137 ((LinkedHashMap<String, Object>) dataNodes
138 .get(parentPropertiesMap.get(ToscaSchemaConstants.TYPE))).entrySet()
139 .stream().forEach(pmap -> {
140 if (pmap.getKey().equalsIgnoreCase(
141 ToscaSchemaConstants.PROPERTIES)) {
142 parseToscaProperties(ToscaSchemaConstants.POLICY_NODE,
143 (LinkedHashMap<String, Object>) pmap.getValue(),
144 jsonParentObject, rootNodeArray,
145 jsonEntrySchema, dataNodes,
146 incrementSimpleTypeOrder());
151 jsonTempObject.put(JsonEditorSchemaConstants.TYPE,
152 JsonEditorSchemaConstants.TYPE_ARRAY);
153 parseDescription((LinkedHashMap<String, Object>) ntPropertiesElement.getValue(),
155 jsonTempObject.put(JsonEditorSchemaConstants.ITEMS, jsonParentObject);
156 jsonTempObject.put(JsonEditorSchemaConstants.FORMAT,
157 JsonEditorSchemaConstants.CUSTOM_KEY_FORMAT_TABS_TOP);
158 jsonTempObject.put(JsonEditorSchemaConstants.UNIQUE_ITEMS,
159 JsonEditorSchemaConstants.TRUE);
168 @SuppressWarnings("unchecked")
169 private void parseToscaProperties(String parentKey, LinkedHashMap<String, Object> propertiesMap,
170 JSONObject jsonDataNode, JSONArray array, Map<String, JSONObject> jsonEntrySchema,
171 LinkedHashMap<String, Object> dataNodes, final int order) {
172 JSONObject jsonPropertyNode = new JSONObject();
173 propertiesMap.entrySet().stream().forEach(p -> {
174 // Populate JSON Array for "required" key
176 if (p.getValue() instanceof Map) {
177 LinkedHashMap<String, Object> nodeMap = (LinkedHashMap<String, Object>) p.getValue();
178 if (nodeMap.containsKey(ToscaSchemaConstants.REQUIRED)
179 && ((boolean) nodeMap.get(ToscaSchemaConstants.REQUIRED))) {
180 array.put(p.getKey());
182 // if(nodeMap.containsKey(ToscaSchemaConstants.CONSTRAINTS))
183 parseToscaChildNodeMap(p.getKey(), nodeMap, jsonPropertyNode, jsonEntrySchema, dataNodes, array,
184 incrementSimpleTypeOrder());
187 jsonDataNode.put(JsonEditorSchemaConstants.REQUIRED, array);
188 jsonDataNode.put(JsonEditorSchemaConstants.PROPERTIES, jsonPropertyNode);
191 @SuppressWarnings("unchecked")
192 private void parseToscaPropertiesForType(String parentKey, LinkedHashMap<String, Object> propertiesMap,
193 JSONObject jsonDataNode, JSONArray array, Map<String, JSONObject> jsonEntrySchema,
194 LinkedHashMap<String, Object> dataNodes, boolean isType, int order) {
195 JSONObject jsonPropertyNode = new JSONObject();
197 propertiesMap.entrySet().stream().forEach(p -> {
198 // array.put(p.getKey());
199 boolean overWriteArray = false;
200 if (p.getValue() instanceof Map) {
201 LinkedHashMap<String, Object> nodeMap = (LinkedHashMap<String, Object>) p.getValue();
202 if (!(parentKey.contains(ToscaSchemaConstants.ENTRY_SCHEMA)
203 || parentKey.contains(ToscaSchemaConstants.POLICY_NODE))
204 && nodeMap.containsKey(ToscaSchemaConstants.TYPE)
205 && (((String) nodeMap.get(ToscaSchemaConstants.TYPE))
206 .contains(ToscaSchemaConstants.POLICY_DATA))) {
207 overWriteArray = true;
209 if (nodeMap.containsKey(ToscaSchemaConstants.REQUIRED)
210 && ((boolean) nodeMap.get(ToscaSchemaConstants.REQUIRED))) {
211 array.put(p.getKey());
213 parseToscaChildNodeMap(p.getKey(), nodeMap, jsonPropertyNode, jsonEntrySchema, dataNodes, array, order);
216 jsonDataNode.put(JsonEditorSchemaConstants.REQUIRED, array);
217 jsonDataNode.put(JsonEditorSchemaConstants.PROPERTIES, jsonPropertyNode);
220 private void parseToscaChildNodeMap(String childObjectKey, LinkedHashMap<String, Object> childNodeMap,
221 JSONObject jsonPropertyNode, Map<String, JSONObject> jsonEntrySchema,
222 LinkedHashMap<String, Object> dataNodes, JSONArray array, int order) {
223 JSONObject childObject = new JSONObject();
224 // JSONArray childArray = new JSONArray();
225 parseDescription(childNodeMap, childObject);
226 parseTypes(childObjectKey, childNodeMap, childObject, jsonEntrySchema, dataNodes, array, order);
227 parseConstraints(childNodeMap, childObject);
228 parseEntrySchema(childNodeMap, childObject, jsonPropertyNode, jsonEntrySchema, dataNodes);
230 jsonPropertyNode.put(childObjectKey, childObject);
235 private void parseEntrySchema(LinkedHashMap<String, Object> childNodeMap, JSONObject childObject,
236 JSONObject jsonPropertyNode, Map<String, JSONObject> jsonEntrySchema,
237 LinkedHashMap<String, Object> dataNodes) {
238 if (childNodeMap.get(ToscaSchemaConstants.ENTRY_SCHEMA) != null) {
239 if (childNodeMap.get(ToscaSchemaConstants.ENTRY_SCHEMA) instanceof Map) {
240 LinkedHashMap<String, Object> entrySchemaMap = (LinkedHashMap<String, Object>) childNodeMap
241 .get(ToscaSchemaConstants.ENTRY_SCHEMA);
242 entrySchemaMap.entrySet().stream().forEach(entry -> {
243 if (entry.getKey().equalsIgnoreCase(ToscaSchemaConstants.TYPE) && entry.getValue() != null) {
244 String entrySchemaType = (String) entry.getValue();
245 if (entrySchemaType.contains(ToscaSchemaConstants.POLICY_DATA)) {
246 JSONArray array = new JSONArray();
247 if (jsonEntrySchema.get(entrySchemaType) != null) {
249 JSONObject entrySchemaObject = jsonEntrySchema.get(entrySchemaType);
250 attachEntrySchemaJsonObject(childObject, entrySchemaObject,
251 JsonEditorSchemaConstants.TYPE_OBJECT);
252 } else if (dataNodes.containsKey(entrySchemaType)) {
254 JSONObject entrySchemaObject = new JSONObject();
256 ((LinkedHashMap<String, Object>) dataNodes.get(entrySchemaType)).entrySet().stream()
258 if (pmap.getKey().equalsIgnoreCase(ToscaSchemaConstants.PROPERTIES)) {
259 parseToscaProperties(ToscaSchemaConstants.ENTRY_SCHEMA,
260 (LinkedHashMap<String, Object>) pmap.getValue(),
261 entrySchemaObject, array, jsonEntrySchema, dataNodes,
262 incrementComplexTypeOrder());
263 jsonEntrySchema.put(entrySchemaType, entrySchemaObject);
264 dataNodes.remove(entrySchemaType);
265 attachEntrySchemaJsonObject(childObject, entrySchemaObject,
266 JsonEditorSchemaConstants.TYPE_OBJECT);
271 } else if (entrySchemaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_STRING)
272 || entrySchemaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_INTEGER)
273 || entrySchemaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_FLOAT)) {
274 JSONObject entrySchemaObject = new JSONObject();
275 parseConstraints(entrySchemaMap, entrySchemaObject);
276 String jsontype = JsonEditorSchemaConstants.TYPE_STRING;
277 if (entrySchemaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_INTEGER)
278 || entrySchemaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_FLOAT)) {
279 jsontype = JsonEditorSchemaConstants.TYPE_INTEGER;
281 if (childNodeMap.get(ToscaSchemaConstants.TYPE) != null) {
282 // Only known value of type is String for now
283 if (childNodeMap.get(ToscaSchemaConstants.TYPE) instanceof String) {
284 String typeValue = (String) childNodeMap.get(ToscaSchemaConstants.TYPE);
285 if (typeValue.equalsIgnoreCase(ToscaSchemaConstants.TYPE_LIST)) {
286 // Custom key for JSON Editor and UI rendering
287 childObject.put(JsonEditorSchemaConstants.CUSTOM_KEY_FORMAT,
288 JsonEditorSchemaConstants.FORMAT_SELECT);
289 // childObject.put(JsonEditorSchemaConstants.UNIQUE_ITEMS,
290 // JsonEditorSchemaConstants.TRUE);
294 attachEntrySchemaJsonObject(childObject, entrySchemaObject, jsontype);
302 private void attachEntrySchemaJsonObject(JSONObject childObject, JSONObject entrySchemaObject, String dataType) {
304 entrySchemaObject.put(JsonEditorSchemaConstants.TYPE, dataType);
305 childObject.put(JsonEditorSchemaConstants.ITEMS, entrySchemaObject);
308 @SuppressWarnings("unchecked")
309 private void attachTypeJsonObject(JSONObject childObject, JSONObject typeObject) {
310 Iterator<String> keys = typeObject.keys();
311 while (keys.hasNext()) {
312 String key = keys.next();
313 childObject.put(key, typeObject.get(key));
318 * private String parseKey(String toscaKey, String lookupString) { return
319 * toscaKey.substring(toscaKey.indexOf(lookupString) + lookupString.length(),
320 * toscaKey.length()); }
323 private void parseDescription(LinkedHashMap<String, Object> childNodeMap, JSONObject childObject) {
324 if (childNodeMap.get(ToscaSchemaConstants.DESCRIPTION) != null) {
325 childObject.put(JsonEditorSchemaConstants.TITLE, childNodeMap.get(ToscaSchemaConstants.DESCRIPTION));
329 private void parseTypes(String childObjectKey, LinkedHashMap<String, Object> childNodeMap, JSONObject childObject,
330 Map<String, JSONObject> jsonEntrySchema, LinkedHashMap<String, Object> dataNodes, JSONArray array,
332 if (childNodeMap.get(ToscaSchemaConstants.TYPE) != null) {
333 // Only known value of type is String for now
334 if (childNodeMap.get(ToscaSchemaConstants.TYPE) instanceof String) {
335 childObject.put(JsonEditorSchemaConstants.PROPERTY_ORDER, order);
336 String typeValue = (String) childNodeMap.get(ToscaSchemaConstants.TYPE);
337 if (typeValue.equalsIgnoreCase(ToscaSchemaConstants.TYPE_INTEGER)) {
338 childObject.put(JsonEditorSchemaConstants.TYPE, JsonEditorSchemaConstants.TYPE_INTEGER);
340 } else if (typeValue.equalsIgnoreCase(ToscaSchemaConstants.TYPE_FLOAT)) {
341 childObject.put(JsonEditorSchemaConstants.TYPE, JsonEditorSchemaConstants.TYPE_INTEGER);
342 } else if (typeValue.equalsIgnoreCase(ToscaSchemaConstants.TYPE_LIST)) {
343 childObject.put(JsonEditorSchemaConstants.TYPE, JsonEditorSchemaConstants.TYPE_ARRAY);
344 // Custom key for JSON Editor and UI rendering
345 childObject.put(JsonEditorSchemaConstants.CUSTOM_KEY_FORMAT,
346 JsonEditorSchemaConstants.CUSTOM_KEY_FORMAT_TABS_TOP);
347 childObject.put(JsonEditorSchemaConstants.UNIQUE_ITEMS, JsonEditorSchemaConstants.TRUE);
348 } else if (typeValue.equalsIgnoreCase(ToscaSchemaConstants.TYPE_MAP)) {
349 childObject.put(JsonEditorSchemaConstants.TYPE, JsonEditorSchemaConstants.TYPE_OBJECT);
350 } else if (typeValue.contains(ToscaSchemaConstants.POLICY_DATA)) {
351 JSONArray childArray = new JSONArray();
353 if (jsonEntrySchema.get(typeValue) != null) {
355 JSONObject entrySchemaObject = jsonEntrySchema.get(typeValue);
356 attachTypeJsonObject(childObject, entrySchemaObject);
357 } else if (dataNodes.containsKey(typeValue)) {
358 JSONObject entrySchemaObject = new JSONObject();
360 JSONArray jsonArray = new JSONArray();
361 ((LinkedHashMap<String, Object>) dataNodes.get(typeValue)).entrySet().stream().forEach(pmap -> {
362 if (pmap.getKey().equalsIgnoreCase(ToscaSchemaConstants.PROPERTIES)) {
364 ((LinkedHashMap<String, Object>) pmap.getValue()).entrySet().stream().forEach(p -> {
365 if (p.getValue() instanceof Map) {
366 LinkedHashMap<String, Object> childNodeMap2 = (LinkedHashMap<String, Object>) p
368 if (childNodeMap2.containsKey(ToscaSchemaConstants.TYPE)
369 && (((String) childNodeMap2.get(ToscaSchemaConstants.TYPE))
370 .contains(ToscaSchemaConstants.POLICY_DATA))) {
376 ((LinkedHashMap<String, Object>) dataNodes.get(typeValue)).entrySet().stream().forEach(pmap -> {
377 if (pmap.getKey().equalsIgnoreCase(ToscaSchemaConstants.PROPERTIES)) {
378 parseToscaPropertiesForType(childObjectKey,
379 (LinkedHashMap<String, Object>) pmap.getValue(), entrySchemaObject, childArray,
380 jsonEntrySchema, dataNodes, true, incrementComplexSimpleTypeOrder());
381 jsonEntrySchema.put(typeValue, entrySchemaObject);
382 dataNodes.remove(typeValue);
383 attachTypeJsonObject(childObject, entrySchemaObject);
388 childObject.put(JsonEditorSchemaConstants.TYPE, JsonEditorSchemaConstants.TYPE_STRING);
391 if (childNodeMap.get(ToscaSchemaConstants.DEFAULT) != null) {
392 childObject.put(JsonEditorSchemaConstants.DEFAULT, childNodeMap.get(ToscaSchemaConstants.DEFAULT));
397 private void parseConstraints(LinkedHashMap<String, Object> childNodeMap, JSONObject childObject) {
398 if (childNodeMap.containsKey(ToscaSchemaConstants.CONSTRAINTS)
399 && childNodeMap.get(ToscaSchemaConstants.CONSTRAINTS) != null) {
400 List<LinkedHashMap<String, Object>> constraintsList = (List<LinkedHashMap<String, Object>>) childNodeMap
401 .get(ToscaSchemaConstants.CONSTRAINTS);
402 constraintsList.stream().forEach(c -> {
403 if (c instanceof Map) {
404 c.entrySet().stream().forEach(constraint -> {
405 if (constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.MIN_LENGTH)
406 || constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.GREATER_OR_EQUAL)) {
407 // For String min_lenghth is minimum length whereas for number, it will be
408 // minimum or greater than to the defined value
409 if (childNodeMap.containsKey(ToscaSchemaConstants.TYPE)
410 && (childNodeMap.get(ToscaSchemaConstants.TYPE) instanceof String)
411 && ((String) childNodeMap.get(ToscaSchemaConstants.TYPE))
412 .equalsIgnoreCase(ToscaSchemaConstants.TYPE_STRING)) {
413 childObject.put(JsonEditorSchemaConstants.MIN_LENGTH, constraint.getValue());
415 childObject.put(JsonEditorSchemaConstants.MINIMUM, constraint.getValue());
417 } else if (constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.MAX_LENGTH)
418 || constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.LESS_OR_EQUAL)) {
419 // For String max_lenghth is maximum length whereas for number, it will be
420 // maximum or less than the defined value
421 if (childNodeMap.containsKey(ToscaSchemaConstants.TYPE)
422 && (childNodeMap.get(ToscaSchemaConstants.TYPE) instanceof String)
423 && ((String) childNodeMap.get(ToscaSchemaConstants.TYPE))
424 .equalsIgnoreCase(ToscaSchemaConstants.TYPE_STRING)) {
425 childObject.put(JsonEditorSchemaConstants.MAX_LENGTH, constraint.getValue());
427 childObject.put(JsonEditorSchemaConstants.MAXIMUM, constraint.getValue());
429 } else if (constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.LESS_THAN)) {
430 childObject.put(JsonEditorSchemaConstants.EXCLUSIVE_MAXIMUM, constraint.getValue());
431 } else if (constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.GREATER_THAN)) {
432 childObject.put(JsonEditorSchemaConstants.EXCLUSIVE_MINIMUM, constraint.getValue());
433 } else if (constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.IN_RANGE)) {
434 if (constraint.getValue() instanceof ArrayList<?>) {
435 if (childNodeMap.containsKey(ToscaSchemaConstants.TYPE)
436 && (childNodeMap.get(ToscaSchemaConstants.TYPE) instanceof String)
437 && ((String) childNodeMap.get(ToscaSchemaConstants.TYPE))
438 .equalsIgnoreCase(ToscaSchemaConstants.TYPE_STRING)) {
439 childObject.put(JsonEditorSchemaConstants.MIN_LENGTH,
440 ((ArrayList) constraint.getValue()).get(0));
441 childObject.put(JsonEditorSchemaConstants.MAX_LENGTH,
442 ((ArrayList) constraint.getValue()).get(1));
444 childObject.put(JsonEditorSchemaConstants.MINIMUM,
445 ((ArrayList) constraint.getValue()).get(0));
446 childObject.put(JsonEditorSchemaConstants.MAXIMUM,
447 ((ArrayList) constraint.getValue()).get(1));
451 } else if (constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.VALID_VALUES)) {
452 JSONArray validValuesArray = new JSONArray();
454 if (constraint.getValue() instanceof ArrayList<?>) {
455 boolean processDictionary = ((ArrayList<?>) constraint.getValue()).stream()
456 .anyMatch(value -> (value instanceof String
457 && ((String) value).contains(ToscaSchemaConstants.DICTIONARY)));
458 if (!processDictionary) {
459 ((ArrayList<?>) constraint.getValue()).stream().forEach(value -> {
460 validValuesArray.put(value);
462 childObject.put(JsonEditorSchemaConstants.ENUM, validValuesArray);
464 ((ArrayList<?>) constraint.getValue()).stream().forEach(value -> {
465 if ((value instanceof String
466 && ((String) value).contains(ToscaSchemaConstants.DICTIONARY))) {
467 processDictionaryElements(childObject, (String) value);
482 private void processDictionaryElements(JSONObject childObject, String dictionaryReference) {
486 private String getJsonType(String toscaType) {
487 String jsonType = null;
488 if (toscaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_INTEGER)) {
489 jsonType = JsonEditorSchemaConstants.TYPE_INTEGER;
490 } else if (toscaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_LIST)) {
491 jsonType = JsonEditorSchemaConstants.TYPE_ARRAY;
493 jsonType = JsonEditorSchemaConstants.TYPE_STRING;