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;
32 import java.util.Optional;
33 import java.util.stream.Collectors;
35 import org.json.JSONArray;
36 import org.json.JSONObject;
37 import org.onap.clamp.clds.dao.CldsDao;
38 import org.onap.clamp.clds.model.CldsDictionaryItem;
39 import org.yaml.snakeyaml.Yaml;
42 * Tosca Model Yaml parser and convertor to JSON Schema consumable for JSON
46 public class ToscaYamlToJsonConvertor {
48 private CldsDao cldsDao;
49 private int simpleTypeOrder = 1000;
50 private int complexTypeOrder = 10000;
51 private int complexSimpleTypeOrder = 1;
53 public ToscaYamlToJsonConvertor(CldsDao cldsDao) {
54 this.cldsDao = cldsDao;
57 private int incrementSimpleTypeOrder() {
58 return simpleTypeOrder++;
61 private int incrementComplexTypeOrder() {
62 return complexTypeOrder = complexTypeOrder + 10000;
65 private int incrementComplexSimpleTypeOrder() {
66 complexSimpleTypeOrder++;
67 return complexTypeOrder + complexSimpleTypeOrder;
73 public CldsDao getCldsDao() {
81 public void setCldsDao(CldsDao cldsDao) {
82 this.cldsDao = cldsDao;
85 @SuppressWarnings("unchecked")
86 public String parseToscaYaml(String yamlString) {
88 Yaml yaml = new Yaml();
89 LinkedHashMap<String, Object> loadedYaml = (LinkedHashMap<String, Object>) yaml.load(yamlString);
90 LinkedHashMap<String, Object> nodeTypes = new LinkedHashMap<String, Object>();
91 LinkedHashMap<String, Object> dataNodes = new LinkedHashMap<String, Object>();
92 JSONObject jsonEditorObject = new JSONObject();
93 JSONObject jsonParentObject = new JSONObject();
94 JSONObject jsonTempObject = new JSONObject();
95 parseNodeAndDataType(loadedYaml, nodeTypes, dataNodes);
96 populateJsonEditorObject(loadedYaml, nodeTypes, dataNodes, jsonParentObject, jsonTempObject);
97 if (jsonTempObject.length() > 0) {
98 jsonParentObject = jsonTempObject;
100 jsonEditorObject.put(JsonEditorSchemaConstants.SCHEMA, jsonParentObject);
101 return jsonEditorObject.toString();
104 // Parse node_type and data_type
105 @SuppressWarnings("unchecked")
106 private void parseNodeAndDataType(LinkedHashMap<String, Object> map, LinkedHashMap<String, Object> nodeTypes,
107 LinkedHashMap<String, Object> dataNodes) {
108 map.entrySet().stream().forEach(n -> {
109 if (n.getKey().contains(ToscaSchemaConstants.NODE_TYPES) && n.getValue() instanceof Map) {
111 parseNodeAndDataType((LinkedHashMap<String, Object>) n.getValue(), nodeTypes, dataNodes);
113 } else if (n.getKey().contains(ToscaSchemaConstants.DATA_TYPES) && n.getValue() instanceof Map) {
115 parseNodeAndDataType((LinkedHashMap<String, Object>) n.getValue(), nodeTypes, dataNodes);
117 } else if (n.getKey().contains(ToscaSchemaConstants.POLICY_NODE)) {
119 nodeTypes.put(n.getKey(), n.getValue());
121 } else if (n.getKey().contains(ToscaSchemaConstants.POLICY_DATA)) {
123 dataNodes.put(n.getKey(), n.getValue());
129 @SuppressWarnings("unchecked")
130 private void populateJsonEditorObject(LinkedHashMap<String, Object> map, LinkedHashMap<String, Object> nodeTypes,
131 LinkedHashMap<String, Object> dataNodes, JSONObject jsonParentObject, JSONObject jsonTempObject) {
133 Map<String, JSONObject> jsonEntrySchema = new HashMap();
134 jsonParentObject.put(JsonEditorSchemaConstants.TYPE, JsonEditorSchemaConstants.TYPE_OBJECT);
135 nodeTypes.entrySet().stream().forEach(nt -> {
136 if (nt.getValue() instanceof Map) {
137 ((LinkedHashMap<String, Object>) nt.getValue()).entrySet().forEach(ntElement -> {
138 if (ntElement.getKey().equalsIgnoreCase(ToscaSchemaConstants.PROPERTIES)) {
139 JSONArray rootNodeArray = new JSONArray();
140 if (ntElement.getValue() instanceof Map) {
141 ((LinkedHashMap<String, Object>) ntElement.getValue()).entrySet()
142 .forEach((ntPropertiesElement) -> {
143 boolean isListNode = false;
144 parseDescription((LinkedHashMap<String, Object>) ntPropertiesElement.getValue(),
146 LinkedHashMap<String, Object> parentPropertiesMap = (LinkedHashMap<String, Object>) ntPropertiesElement
148 if (parentPropertiesMap.containsKey(ToscaSchemaConstants.TYPE)
149 && ((String) parentPropertiesMap.get(ToscaSchemaConstants.TYPE))
150 .contains(ToscaSchemaConstants.TYPE_LIST)
151 && parentPropertiesMap.containsKey(ToscaSchemaConstants.ENTRY_SCHEMA)) {
152 parentPropertiesMap = (LinkedHashMap<String, Object>) parentPropertiesMap
153 .get(ToscaSchemaConstants.ENTRY_SCHEMA);
156 if (parentPropertiesMap.containsKey(ToscaSchemaConstants.TYPE)
157 && ((String) parentPropertiesMap.get(ToscaSchemaConstants.TYPE))
158 .contains(ToscaSchemaConstants.POLICY_DATA)) {
159 ((LinkedHashMap<String, Object>) dataNodes
160 .get(parentPropertiesMap.get(ToscaSchemaConstants.TYPE))).entrySet()
161 .stream().forEach(pmap -> {
163 .equalsIgnoreCase(ToscaSchemaConstants.PROPERTIES)) {
164 parseToscaProperties(ToscaSchemaConstants.POLICY_NODE,
165 (LinkedHashMap<String, Object>) pmap.getValue(),
166 jsonParentObject, rootNodeArray, jsonEntrySchema, dataNodes,
167 incrementSimpleTypeOrder());
174 jsonTempObject.put(JsonEditorSchemaConstants.TYPE,
175 JsonEditorSchemaConstants.TYPE_ARRAY);
176 parseDescription((LinkedHashMap<String, Object>) ntPropertiesElement.getValue(),
178 jsonTempObject.put(JsonEditorSchemaConstants.ITEMS, jsonParentObject);
179 jsonTempObject.put(JsonEditorSchemaConstants.FORMAT,
180 JsonEditorSchemaConstants.CUSTOM_KEY_FORMAT_TABS_TOP);
181 jsonTempObject.put(JsonEditorSchemaConstants.UNIQUE_ITEMS,
182 JsonEditorSchemaConstants.TRUE);
192 @SuppressWarnings("unchecked")
193 private void parseToscaProperties(String parentKey, LinkedHashMap<String, Object> propertiesMap,
194 JSONObject jsonDataNode, JSONArray array, Map<String, JSONObject> jsonEntrySchema,
195 LinkedHashMap<String, Object> dataNodes, final int order) {
196 JSONObject jsonPropertyNode = new JSONObject();
197 propertiesMap.entrySet().stream().forEach(p -> {
198 // Populate JSON Array for "required" key
200 if (p.getValue() instanceof Map) {
201 LinkedHashMap<String, Object> nodeMap = (LinkedHashMap<String, Object>) p.getValue();
202 if (nodeMap.containsKey(ToscaSchemaConstants.REQUIRED)
203 && ((boolean) nodeMap.get(ToscaSchemaConstants.REQUIRED))) {
204 array.put(p.getKey());
206 // if(nodeMap.containsKey(ToscaSchemaConstants.CONSTRAINTS))
207 parseToscaChildNodeMap(p.getKey(), nodeMap, jsonPropertyNode, jsonEntrySchema, dataNodes, array,
208 incrementSimpleTypeOrder());
211 jsonDataNode.put(JsonEditorSchemaConstants.REQUIRED, array);
212 jsonDataNode.put(JsonEditorSchemaConstants.PROPERTIES, jsonPropertyNode);
215 @SuppressWarnings("unchecked")
216 private void parseToscaPropertiesForType(String parentKey, LinkedHashMap<String, Object> propertiesMap,
217 JSONObject jsonDataNode, JSONArray array, Map<String, JSONObject> jsonEntrySchema,
218 LinkedHashMap<String, Object> dataNodes, boolean isType, int order) {
219 JSONObject jsonPropertyNode = new JSONObject();
221 propertiesMap.entrySet().stream().forEach(p -> {
222 // array.put(p.getKey());
223 boolean overWriteArray = false;
224 if (p.getValue() instanceof Map) {
225 LinkedHashMap<String, Object> nodeMap = (LinkedHashMap<String, Object>) p.getValue();
226 if (!(parentKey.contains(ToscaSchemaConstants.ENTRY_SCHEMA)
227 || parentKey.contains(ToscaSchemaConstants.POLICY_NODE))
228 && nodeMap.containsKey(ToscaSchemaConstants.TYPE)
229 && (((String) nodeMap.get(ToscaSchemaConstants.TYPE)).contains(ToscaSchemaConstants.POLICY_DATA))) {
230 overWriteArray = true;
232 if (nodeMap.containsKey(ToscaSchemaConstants.REQUIRED)
233 && ((boolean) nodeMap.get(ToscaSchemaConstants.REQUIRED))) {
234 array.put(p.getKey());
236 parseToscaChildNodeMap(p.getKey(), nodeMap, jsonPropertyNode, jsonEntrySchema, dataNodes, array, order);
239 jsonDataNode.put(JsonEditorSchemaConstants.REQUIRED, array);
240 jsonDataNode.put(JsonEditorSchemaConstants.PROPERTIES, jsonPropertyNode);
243 private void parseToscaChildNodeMap(String childObjectKey, LinkedHashMap<String, Object> childNodeMap,
244 JSONObject jsonPropertyNode, Map<String, JSONObject> jsonEntrySchema, LinkedHashMap<String, Object> dataNodes,
245 JSONArray array, int order) {
246 JSONObject childObject = new JSONObject();
247 // JSONArray childArray = new JSONArray();
248 parseDescription(childNodeMap, childObject);
249 parseTypes(childObjectKey, childNodeMap, childObject, jsonEntrySchema, dataNodes, array, order);
250 parseConstraints(childNodeMap, childObject);
251 parseEntrySchema(childNodeMap, childObject, jsonPropertyNode, jsonEntrySchema, dataNodes);
253 jsonPropertyNode.put(childObjectKey, childObject);
258 private void parseEntrySchema(LinkedHashMap<String, Object> childNodeMap, JSONObject childObject,
259 JSONObject jsonPropertyNode, Map<String, JSONObject> jsonEntrySchema, LinkedHashMap<String, Object> dataNodes) {
260 if (childNodeMap.get(ToscaSchemaConstants.ENTRY_SCHEMA) != null) {
261 if (childNodeMap.get(ToscaSchemaConstants.ENTRY_SCHEMA) instanceof Map) {
262 LinkedHashMap<String, Object> entrySchemaMap = (LinkedHashMap<String, Object>) childNodeMap
263 .get(ToscaSchemaConstants.ENTRY_SCHEMA);
264 entrySchemaMap.entrySet().stream().forEach(entry -> {
265 if (entry.getKey().equalsIgnoreCase(ToscaSchemaConstants.TYPE) && entry.getValue() != null) {
266 String entrySchemaType = (String) entry.getValue();
267 if (entrySchemaType.contains(ToscaSchemaConstants.POLICY_DATA)) {
268 JSONArray array = new JSONArray();
269 if (jsonEntrySchema.get(entrySchemaType) != null) {
271 JSONObject entrySchemaObject = jsonEntrySchema.get(entrySchemaType);
272 attachEntrySchemaJsonObject(childObject, entrySchemaObject,
273 JsonEditorSchemaConstants.TYPE_OBJECT);
274 } else if (dataNodes.containsKey(entrySchemaType)) {
276 JSONObject entrySchemaObject = new JSONObject();
278 ((LinkedHashMap<String, Object>) dataNodes.get(entrySchemaType)).entrySet().stream()
280 if (pmap.getKey().equalsIgnoreCase(ToscaSchemaConstants.PROPERTIES)) {
281 parseToscaProperties(ToscaSchemaConstants.ENTRY_SCHEMA,
282 (LinkedHashMap<String, Object>) pmap.getValue(), entrySchemaObject,
283 array, jsonEntrySchema, dataNodes, incrementComplexTypeOrder());
284 jsonEntrySchema.put(entrySchemaType, entrySchemaObject);
285 dataNodes.remove(entrySchemaType);
286 attachEntrySchemaJsonObject(childObject, entrySchemaObject,
287 JsonEditorSchemaConstants.TYPE_OBJECT);
292 } else if (entrySchemaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_STRING)
293 || entrySchemaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_INTEGER)
294 || entrySchemaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_FLOAT)) {
295 JSONObject entrySchemaObject = new JSONObject();
296 parseConstraints(entrySchemaMap, entrySchemaObject);
297 String jsontype = JsonEditorSchemaConstants.TYPE_STRING;
298 if (entrySchemaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_INTEGER)
299 || entrySchemaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_FLOAT)) {
300 jsontype = JsonEditorSchemaConstants.TYPE_INTEGER;
302 if (childNodeMap.get(ToscaSchemaConstants.TYPE) != null) {
303 // Only known value of type is String for now
304 if (childNodeMap.get(ToscaSchemaConstants.TYPE) instanceof String) {
305 String typeValue = (String) childNodeMap.get(ToscaSchemaConstants.TYPE);
306 if (typeValue.equalsIgnoreCase(ToscaSchemaConstants.TYPE_LIST)) {
307 // Custom key for JSON Editor and UI rendering
308 childObject.put(JsonEditorSchemaConstants.CUSTOM_KEY_FORMAT,
309 JsonEditorSchemaConstants.FORMAT_SELECT);
310 // childObject.put(JsonEditorSchemaConstants.UNIQUE_ITEMS,
311 // JsonEditorSchemaConstants.TRUE);
315 attachEntrySchemaJsonObject(childObject, entrySchemaObject, jsontype);
323 private void attachEntrySchemaJsonObject(JSONObject childObject, JSONObject entrySchemaObject, String dataType) {
325 entrySchemaObject.put(JsonEditorSchemaConstants.TYPE, dataType);
326 childObject.put(JsonEditorSchemaConstants.ITEMS, entrySchemaObject);
329 @SuppressWarnings("unchecked")
330 private void attachTypeJsonObject(JSONObject childObject, JSONObject typeObject) {
331 Iterator<String> keys = typeObject.keys();
332 while (keys.hasNext()) {
333 String key = keys.next();
334 childObject.put(key, typeObject.get(key));
339 * private String parseKey(String toscaKey, String lookupString) { return
340 * toscaKey.substring(toscaKey.indexOf(lookupString) + lookupString.length(),
341 * toscaKey.length()); }
344 private void parseDescription(LinkedHashMap<String, Object> childNodeMap, JSONObject childObject) {
345 if (childNodeMap.get(ToscaSchemaConstants.DESCRIPTION) != null) {
346 childObject.put(JsonEditorSchemaConstants.TITLE, childNodeMap.get(ToscaSchemaConstants.DESCRIPTION));
350 private void parseTypes(String childObjectKey, LinkedHashMap<String, Object> childNodeMap, JSONObject childObject,
351 Map<String, JSONObject> jsonEntrySchema, LinkedHashMap<String, Object> dataNodes, JSONArray array, int order) {
352 if (childNodeMap.get(ToscaSchemaConstants.TYPE) != null) {
353 // Only known value of type is String for now
354 if (childNodeMap.get(ToscaSchemaConstants.TYPE) instanceof String) {
355 childObject.put(JsonEditorSchemaConstants.PROPERTY_ORDER, order);
356 String typeValue = (String) childNodeMap.get(ToscaSchemaConstants.TYPE);
357 if (typeValue.equalsIgnoreCase(ToscaSchemaConstants.TYPE_INTEGER)) {
358 childObject.put(JsonEditorSchemaConstants.TYPE, JsonEditorSchemaConstants.TYPE_INTEGER);
360 } else if (typeValue.equalsIgnoreCase(ToscaSchemaConstants.TYPE_FLOAT)) {
361 childObject.put(JsonEditorSchemaConstants.TYPE, JsonEditorSchemaConstants.TYPE_INTEGER);
362 } else if (typeValue.equalsIgnoreCase(ToscaSchemaConstants.TYPE_LIST)) {
363 childObject.put(JsonEditorSchemaConstants.TYPE, JsonEditorSchemaConstants.TYPE_ARRAY);
364 // Custom key for JSON Editor and UI rendering
365 childObject.put(JsonEditorSchemaConstants.CUSTOM_KEY_FORMAT,
366 JsonEditorSchemaConstants.CUSTOM_KEY_FORMAT_TABS_TOP);
367 childObject.put(JsonEditorSchemaConstants.UNIQUE_ITEMS, JsonEditorSchemaConstants.TRUE);
368 } else if (typeValue.equalsIgnoreCase(ToscaSchemaConstants.TYPE_MAP)) {
369 childObject.put(JsonEditorSchemaConstants.TYPE, JsonEditorSchemaConstants.TYPE_OBJECT);
370 } else if (typeValue.contains(ToscaSchemaConstants.POLICY_DATA)) {
371 JSONArray childArray = new JSONArray();
373 if (jsonEntrySchema.get(typeValue) != null) {
375 JSONObject entrySchemaObject = jsonEntrySchema.get(typeValue);
376 attachTypeJsonObject(childObject, entrySchemaObject);
377 } else if (dataNodes.containsKey(typeValue)) {
378 JSONObject entrySchemaObject = new JSONObject();
380 JSONArray jsonArray = new JSONArray();
381 ((LinkedHashMap<String, Object>) dataNodes.get(typeValue)).entrySet().stream().forEach(pmap -> {
382 if (pmap.getKey().equalsIgnoreCase(ToscaSchemaConstants.PROPERTIES)) {
384 ((LinkedHashMap<String, Object>) pmap.getValue()).entrySet().stream().forEach(p -> {
385 if (p.getValue() instanceof Map) {
386 LinkedHashMap<String, Object> childNodeMap2 = (LinkedHashMap<String, Object>) p
388 if (childNodeMap2.containsKey(ToscaSchemaConstants.TYPE)
389 && (((String) childNodeMap2.get(ToscaSchemaConstants.TYPE))
390 .contains(ToscaSchemaConstants.POLICY_DATA))) {
396 ((LinkedHashMap<String, Object>) dataNodes.get(typeValue)).entrySet().stream().forEach(pmap -> {
397 if (pmap.getKey().equalsIgnoreCase(ToscaSchemaConstants.PROPERTIES)) {
398 parseToscaPropertiesForType(childObjectKey,
399 (LinkedHashMap<String, Object>) pmap.getValue(), entrySchemaObject, childArray,
400 jsonEntrySchema, dataNodes, true, incrementComplexSimpleTypeOrder());
401 jsonEntrySchema.put(typeValue, entrySchemaObject);
402 dataNodes.remove(typeValue);
403 attachTypeJsonObject(childObject, entrySchemaObject);
408 childObject.put(JsonEditorSchemaConstants.TYPE, JsonEditorSchemaConstants.TYPE_STRING);
411 if (childNodeMap.get(ToscaSchemaConstants.DEFAULT) != null) {
412 childObject.put(JsonEditorSchemaConstants.DEFAULT, childNodeMap.get(ToscaSchemaConstants.DEFAULT));
417 private void parseConstraints(LinkedHashMap<String, Object> childNodeMap, JSONObject childObject) {
418 if (childNodeMap.containsKey(ToscaSchemaConstants.CONSTRAINTS)
419 && childNodeMap.get(ToscaSchemaConstants.CONSTRAINTS) != null) {
420 List<LinkedHashMap<String, Object>> constraintsList = (List<LinkedHashMap<String, Object>>) childNodeMap
421 .get(ToscaSchemaConstants.CONSTRAINTS);
422 constraintsList.stream().forEach(c -> {
423 if (c instanceof Map) {
424 c.entrySet().stream().forEach(constraint -> {
425 if (constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.MIN_LENGTH)
426 || constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.GREATER_OR_EQUAL)) {
427 // For String min_lenghth is minimum length whereas for number, it will be
428 // minimum or greater than to the defined value
429 if (childNodeMap.containsKey(ToscaSchemaConstants.TYPE)
430 && (childNodeMap.get(ToscaSchemaConstants.TYPE) instanceof String)
431 && ((String) childNodeMap.get(ToscaSchemaConstants.TYPE))
432 .equalsIgnoreCase(ToscaSchemaConstants.TYPE_STRING)) {
433 childObject.put(JsonEditorSchemaConstants.MIN_LENGTH, constraint.getValue());
435 childObject.put(JsonEditorSchemaConstants.MINIMUM, constraint.getValue());
437 } else if (constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.MAX_LENGTH)
438 || constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.LESS_OR_EQUAL)) {
439 // For String max_lenghth is maximum length whereas for number, it will be
440 // maximum or less than the defined value
441 if (childNodeMap.containsKey(ToscaSchemaConstants.TYPE)
442 && (childNodeMap.get(ToscaSchemaConstants.TYPE) instanceof String)
443 && ((String) childNodeMap.get(ToscaSchemaConstants.TYPE))
444 .equalsIgnoreCase(ToscaSchemaConstants.TYPE_STRING)) {
445 childObject.put(JsonEditorSchemaConstants.MAX_LENGTH, constraint.getValue());
447 childObject.put(JsonEditorSchemaConstants.MAXIMUM, constraint.getValue());
449 } else if (constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.LESS_THAN)) {
450 childObject.put(JsonEditorSchemaConstants.EXCLUSIVE_MAXIMUM, constraint.getValue());
451 } else if (constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.GREATER_THAN)) {
452 childObject.put(JsonEditorSchemaConstants.EXCLUSIVE_MINIMUM, constraint.getValue());
453 } else if (constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.IN_RANGE)) {
454 if (constraint.getValue() instanceof ArrayList<?>) {
455 if (childNodeMap.containsKey(ToscaSchemaConstants.TYPE)
456 && (childNodeMap.get(ToscaSchemaConstants.TYPE) instanceof String)
457 && ((String) childNodeMap.get(ToscaSchemaConstants.TYPE))
458 .equalsIgnoreCase(ToscaSchemaConstants.TYPE_STRING)) {
459 childObject.put(JsonEditorSchemaConstants.MIN_LENGTH,
460 ((ArrayList) constraint.getValue()).get(0));
461 childObject.put(JsonEditorSchemaConstants.MAX_LENGTH,
462 ((ArrayList) constraint.getValue()).get(1));
464 childObject.put(JsonEditorSchemaConstants.MINIMUM,
465 ((ArrayList) constraint.getValue()).get(0));
466 childObject.put(JsonEditorSchemaConstants.MAXIMUM,
467 ((ArrayList) constraint.getValue()).get(1));
471 } else if (constraint.getKey().equalsIgnoreCase(ToscaSchemaConstants.VALID_VALUES)) {
472 JSONArray validValuesArray = new JSONArray();
474 if (constraint.getValue() instanceof ArrayList<?>) {
475 boolean processDictionary = ((ArrayList<?>) constraint.getValue()).stream()
476 .anyMatch(value -> (value instanceof String
477 && ((String) value).contains(ToscaSchemaConstants.DICTIONARY)));
478 if (!processDictionary) {
479 ((ArrayList<?>) constraint.getValue()).stream().forEach(value -> {
480 validValuesArray.put(value);
482 childObject.put(JsonEditorSchemaConstants.ENUM, validValuesArray);
484 ((ArrayList<?>) constraint.getValue()).stream().forEach(value -> {
485 if ((value instanceof String
486 && ((String) value).contains(ToscaSchemaConstants.DICTIONARY))) {
487 processDictionaryElements(childObject, (String) value);
502 private void processDictionaryElements(JSONObject childObject, String dictionaryReference) {
504 if (dictionaryReference.contains("#")) {
505 String[] dictionaryKeyArray = dictionaryReference
506 .substring(dictionaryReference.indexOf(ToscaSchemaConstants.DICTIONARY) + 11,
507 dictionaryReference.length())
509 // We support only one # as of now.
510 List<CldsDictionaryItem> cldsDictionaryElements = null;
511 List<CldsDictionaryItem> subDictionaryElements = null;
512 if (dictionaryKeyArray != null && dictionaryKeyArray.length == 2) {
513 cldsDictionaryElements = getCldsDao().getDictionaryElements(dictionaryKeyArray[0], null, null);
514 subDictionaryElements = getCldsDao().getDictionaryElements(dictionaryKeyArray[1], null, null);
516 if (cldsDictionaryElements != null) {
517 List<String> subCldsDictionaryNames = subDictionaryElements.stream()
518 .map(CldsDictionaryItem::getDictElementShortName).collect(Collectors.toList());
519 JSONArray jsonArray = new JSONArray();
521 Optional.ofNullable(cldsDictionaryElements).get().stream().forEach(c -> {
522 JSONObject jsonObject = new JSONObject();
523 jsonObject.put(JsonEditorSchemaConstants.TYPE, getJsonType(c.getDictElementType()));
524 if (c.getDictElementType() != null
525 && c.getDictElementType().equalsIgnoreCase(ToscaSchemaConstants.TYPE_STRING)) {
526 jsonObject.put(JsonEditorSchemaConstants.MIN_LENGTH, 1);
528 jsonObject.put(JsonEditorSchemaConstants.ID, c.getDictElementName());
529 jsonObject.put(JsonEditorSchemaConstants.LABEL, c.getDictElementShortName());
530 jsonObject.put(JsonEditorSchemaConstants.OPERATORS, subCldsDictionaryNames);
531 jsonArray.put(jsonObject);
534 JSONObject filterObject = new JSONObject();
535 filterObject.put(JsonEditorSchemaConstants.FILTERS, jsonArray);
537 childObject.put(JsonEditorSchemaConstants.TYPE, JsonEditorSchemaConstants.TYPE_QBLDR);
538 // TO invoke validation on such parameters
539 childObject.put(JsonEditorSchemaConstants.MIN_LENGTH, 1);
540 childObject.put(JsonEditorSchemaConstants.QSSCHEMA, filterObject);
545 String dictionaryKey = dictionaryReference.substring(
546 dictionaryReference.indexOf(ToscaSchemaConstants.DICTIONARY) + 11, dictionaryReference.length());
547 if (dictionaryKey != null) {
548 List<CldsDictionaryItem> cldsDictionaryElements = getCldsDao().getDictionaryElements(dictionaryKey,
550 if (cldsDictionaryElements != null) {
551 List<String> cldsDictionaryNames = new ArrayList<>();
552 List<String> cldsDictionaryFullNames = new ArrayList<>();
553 cldsDictionaryElements.stream().forEach(c -> {
554 // Json type will be translated before Policy creation
555 if (c.getDictElementType() != null && !c.getDictElementType().equalsIgnoreCase("json")) {
556 cldsDictionaryFullNames.add(c.getDictElementName());
558 cldsDictionaryNames.add(c.getDictElementShortName());
561 if (cldsDictionaryFullNames.size() > 0) {
562 childObject.put(JsonEditorSchemaConstants.ENUM, cldsDictionaryFullNames);
563 // Add Enum titles for generated translated values during JSON instance
565 JSONObject enumTitles = new JSONObject();
566 enumTitles.put(JsonEditorSchemaConstants.ENUM_TITLES, cldsDictionaryNames);
567 childObject.put(JsonEditorSchemaConstants.OPTIONS, enumTitles);
569 childObject.put(JsonEditorSchemaConstants.ENUM, cldsDictionaryNames);
577 private String getJsonType(String toscaType) {
578 String jsonType = null;
579 if (toscaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_INTEGER)) {
580 jsonType = JsonEditorSchemaConstants.TYPE_INTEGER;
581 } else if (toscaType.equalsIgnoreCase(ToscaSchemaConstants.TYPE_LIST)) {
582 jsonType = JsonEditorSchemaConstants.TYPE_ARRAY;
584 jsonType = JsonEditorSchemaConstants.TYPE_STRING;