catalog-be/src/main/java/org/openecomp/sdc/be/components/csar/YamlTemplateParsingHandler.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  * Modifications copyright (c) 2019 Nokia
  20  * ================================================================================
  21  */
  22 package org.openecomp.sdc.be.components.csar;
  23
  24 import com.google.common.collect.Lists;
  25 import com.google.common.collect.Maps;
  26 import com.google.gson.Gson;
  27 import fj.data.Either;
  28 import java.util.Collections;
  29 import java.util.EnumMap;
  30 import java.util.Objects;
  31 import org.apache.commons.collections.CollectionUtils;
  32 import org.apache.commons.collections.MapUtils;
  33 import org.apache.commons.lang.StringUtils;
  34 import org.openecomp.sdc.be.components.impl.AnnotationBusinessLogic;
  35 import org.openecomp.sdc.be.components.impl.GroupTypeBusinessLogic;
  36 import org.openecomp.sdc.be.components.impl.ImportUtils;
  37 import org.openecomp.sdc.be.components.impl.NodeFilterUploadCreator;
  38 import org.openecomp.sdc.be.components.impl.PolicyTypeBusinessLogic;
  39 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
  40 import org.openecomp.sdc.be.components.utils.PropertiesUtils;
  41 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  42 import org.openecomp.sdc.be.dao.api.ActionStatus;
  43 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  44 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
  45 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
  46 import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType;
  47 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  48 import org.openecomp.sdc.be.model.CapabilityDefinition;
  49 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  50 import org.openecomp.sdc.be.model.GroupDefinition;
  51 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  52 import org.openecomp.sdc.be.model.InputDefinition;
  53 import org.openecomp.sdc.be.model.NodeTypeInfo;
  54 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
  55 import org.openecomp.sdc.be.model.PolicyDefinition;
  56 import org.openecomp.sdc.be.model.PolicyTypeDefinition;
  57 import org.openecomp.sdc.be.model.UploadArtifactInfo;
  58 import org.openecomp.sdc.be.model.UploadCapInfo;
  59 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
  60 import org.openecomp.sdc.be.model.UploadPropInfo;
  61 import org.openecomp.sdc.be.model.UploadReqInfo;
  62 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
  63 import org.openecomp.sdc.be.utils.TypeUtils;
  64 import org.openecomp.sdc.common.log.wrappers.Logger;
  65 import org.springframework.stereotype.Component;
  66 import org.yaml.snakeyaml.parser.ParserException;
  67
  68 import java.util.ArrayList;
  69 import java.util.Collection;
  70 import java.util.HashMap;
  71 import java.util.List;
  72 import java.util.Map;
  73 import java.util.Set;
  74 import java.util.regex.Pattern;
  75 import java.util.stream.Collectors;
  76
  77 import static java.util.stream.Collectors.toList;
  78 import static org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
  79 import static org.openecomp.sdc.be.components.impl.ImportUtils.ToscaElementTypeEnum;
  80 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaListElement;
  81 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaMapElement;
  82 import static org.openecomp.sdc.be.components.impl.ImportUtils.findToscaElement;
  83 import static org.openecomp.sdc.be.components.impl.ImportUtils.loadYamlAsStrictMap;
  84 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.ARTIFACTS;
  85 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.CAPABILITIES;
  86 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.CAPABILITY;
  87 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT_VALUE;
  88 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DESCRIPTION;
  89 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.FILE;
  90 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.GET_INPUT;
  91 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.GROUPS;
  92 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.IS_PASSWORD;
  93 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.MEMBERS;
  94 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.NODE;
  95 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.NODE_TEMPLATES;
  96 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.POLICIES;
  97 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.PROPERTIES;
  98 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.REQUIREMENTS;
  99 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.SUBSTITUTION_MAPPINGS;
 100 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TARGETS;
 101 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE;
 102 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TYPE;
 103 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.VALID_SOURCE_TYPES;
 104
 105 /**
 106  * A handler class designed to parse the YAML file of the service template for a JAVA object
 107  */
 108 @Component
 109 public class YamlTemplateParsingHandler {
 110
 111     private static final Pattern propertyValuePattern = Pattern.compile("[ ]*\\{[ ]*(str_replace=|token=|get_property=|concat=|get_attribute=)+");
 112     private static final int SUB_MAPPING_CAPABILITY_OWNER_NAME_IDX = 0;
 113     private static final int SUB_MAPPING_CAPABILITY_NAME_IDX = 1;
 114     private static final Logger log = Logger.getLogger(YamlTemplateParsingHandler.class);
 115
 116
 117     private Gson gson = new Gson();
 118     private JanusGraphDao janusGraphDao;
 119     private GroupTypeBusinessLogic groupTypeBusinessLogic;
 120     private AnnotationBusinessLogic annotationBusinessLogic;
 121     private PolicyTypeBusinessLogic policyTypeBusinessLogic;
 122
 123     public YamlTemplateParsingHandler(JanusGraphDao janusGraphDao, GroupTypeBusinessLogic groupTypeBusinessLogic,
 124             AnnotationBusinessLogic annotationBusinessLogic, PolicyTypeBusinessLogic policyTypeBusinessLogic) {
 125         this.janusGraphDao = janusGraphDao;
 126         this.groupTypeBusinessLogic = groupTypeBusinessLogic;
 127         this.annotationBusinessLogic = annotationBusinessLogic;
 128         this.policyTypeBusinessLogic = policyTypeBusinessLogic;
 129     }
 130
 131     public ParsedToscaYamlInfo parseResourceInfoFromYAML(String fileName, String resourceYml, Map<String, String> createdNodesToscaResourceNames,
 132                                                          Map<String, NodeTypeInfo> nodeTypesInfo, String nodeName) {
 133         log.debug("#parseResourceInfoFromYAML - Going to parse yaml {} ", fileName);
 134         Map<String, Object> mappedToscaTemplate = getMappedToscaTemplate(fileName, resourceYml, nodeTypesInfo, nodeName);
 135         ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
 136         findToscaElement(mappedToscaTemplate, TOPOLOGY_TEMPLATE, ToscaElementTypeEnum.ALL)
 137                 .left()
 138                 .on(err -> failIfNotTopologyTemplate(fileName));
 139
 140         parsedToscaYamlInfo.setInputs(getInputs(mappedToscaTemplate));
 141         parsedToscaYamlInfo.setInstances(getInstances(fileName, mappedToscaTemplate, createdNodesToscaResourceNames));
 142         parsedToscaYamlInfo.setGroups(getGroups(fileName, mappedToscaTemplate));
 143         parsedToscaYamlInfo.setPolicies(getPolicies(fileName, mappedToscaTemplate));
 144         log.debug("#parseResourceInfoFromYAML - The yaml {} has been parsed ", fileName);
 145         return parsedToscaYamlInfo;
 146     }
 147
 148     private Map<String, Object> getMappedToscaTemplate(String fileName, String resourceYml, Map<String, NodeTypeInfo> nodeTypesInfo, String nodeName) {
 149         Map<String, Object> mappedToscaTemplate;
 150         if (isNodeExist(nodeTypesInfo, nodeName)) {
 151             mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
 152         } else {
 153             mappedToscaTemplate = loadYaml(fileName, resourceYml);
 154         }
 155         return mappedToscaTemplate;
 156     }
 157
 158     private Map<String, Object> loadYaml(String fileName, String resourceYml) {
 159         Map<String, Object> mappedToscaTemplate = null;
 160         try {
 161             mappedToscaTemplate = loadYamlAsStrictMap(resourceYml);
 162         } catch (ParserException e) {
 163             log.debug("#getMappedToscaTemplate - Failed to load YAML file {}", fileName, e);
 164             rollbackWithException(ActionStatus.TOSCA_PARSE_ERROR, fileName, e.getMessage());
 165         }
 166         return mappedToscaTemplate;
 167     }
 168
 169     private boolean isNodeExist(Map<String, NodeTypeInfo> nodeTypesInfo, String nodeName) {
 170         return nodeTypesInfo != null && nodeName != null && nodeTypesInfo.containsKey(nodeName);
 171     }
 172
 173     private Map<String, InputDefinition> getInputs(Map<String, Object> toscaJson) {
 174         Map<String, InputDefinition> inputs = ImportUtils.getInputs(toscaJson, annotationBusinessLogic.getAnnotationTypeOperations())
 175                 .left()
 176                 .on(err -> new HashMap<>());
 177         annotationBusinessLogic.validateAndMergeAnnotationsAndAssignToInput(inputs);
 178         return inputs;
 179     }
 180
 181     private Map<String, PolicyDefinition> getPolicies(String fileName, Map<String, Object> toscaJson) {
 182
 183         Map<String, Object> foundPolicies = findFirstToscaMapElement(toscaJson, POLICIES)
 184                                                   .left()
 185                                                   .on(err -> logPoliciesNotFound(fileName));
 186         Map<String, Object> foundNodeTemplates = findFirstToscaMapElement(toscaJson, NODE_TEMPLATES)
 187                                                   .left()
 188                                                   .on(err -> failIfNoNodeTemplates(fileName));
 189         Map<String, Object> foundGroups = findFirstToscaMapElement(toscaJson, GROUPS)
 190                                                     .left()
 191                                                     .on(err -> logGroupsNotFound(fileName));
 192
 193         if (MapUtils.isNotEmpty(foundPolicies)) {
 194             return foundPolicies
 195                            .entrySet()
 196                            .stream()
 197                            .map(policyNameValue -> createPolicy(policyNameValue, foundNodeTemplates, foundGroups))
 198                            .collect(Collectors.toMap(PolicyDefinition::getName, p -> p));
 199         }
 200         return Collections.emptyMap();
 201     }
 202
 203     private PolicyDefinition createPolicy(Map.Entry<String, Object> policyNameValue,
 204         Map<String, Object> nodeTemplatesJson, Map<String, Object> groupsTemplateJson) {
 205         PolicyDefinition emptyPolicyDef = new PolicyDefinition();
 206         String policyName = policyNameValue.getKey();
 207         emptyPolicyDef.setName(policyName);
 208         try {
 209             if (policyNameValue.getValue() != null && policyNameValue.getValue() instanceof Map) {
 210                 Map<String, Object> policyTemplateJsonMap = (Map<String, Object>) policyNameValue.getValue();
 211                 validateAndFillPolicy(emptyPolicyDef, policyTemplateJsonMap, nodeTemplatesJson, groupsTemplateJson);
 212             } else {
 213                 rollbackWithException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
 214             }
 215         } catch (ClassCastException e) {
 216             log.debug("#createPolicy - Failed to create the policy {}. The exception occurred", policyName, e);
 217             rollbackWithException(ActionStatus.INVALID_YAML);
 218         }
 219         return emptyPolicyDef;
 220     }
 221
 222     private Map<String, Object> logPoliciesNotFound(String fileName) {
 223         log.debug("#logPoliciesNotFound - Policies were not found in the yaml template {}.", fileName);
 224         return Collections.emptyMap();
 225     }
 226
 227     private void validateAndFillPolicy(PolicyDefinition emptyPolicyDefinition,
 228         Map<String, Object> policyTemplateJsonMap, Map<String, Object> nodeTemplatesJson,
 229         Map<String, Object> groupsTemplateJson) {
 230         String policyTypeName = (String) policyTemplateJsonMap.get(TYPE.getElementName());
 231         if(StringUtils.isEmpty(policyTypeName)){
 232             log.debug("#validateAndFillPolicy - The 'type' member is not found under policy {}", emptyPolicyDefinition.getName());
 233             rollbackWithException(ActionStatus.POLICY_MISSING_POLICY_TYPE, emptyPolicyDefinition.getName());
 234         }
 235         emptyPolicyDefinition.setType(policyTypeName);
 236         // set policy targets
 237         emptyPolicyDefinition.setTargets(validateFillPolicyTargets(policyTemplateJsonMap, nodeTemplatesJson, groupsTemplateJson));
 238         PolicyTypeDefinition policyTypeDefinition = validateGetPolicyTypeDefinition(policyTypeName);
 239         // set policy properties
 240         emptyPolicyDefinition.setProperties(validateFillPolicyProperties(policyTypeDefinition, policyTemplateJsonMap));
 241     }
 242
 243     private PolicyTypeDefinition validateGetPolicyTypeDefinition(String policyType) {
 244         PolicyTypeDefinition policyTypeDefinition = policyTypeBusinessLogic.getLatestPolicyTypeByType(policyType);
 245         if (policyTypeDefinition == null) {
 246             log.debug("#validateAndFillPolicy - The policy type {} not found", policyType);
 247             rollbackWithException(ActionStatus.POLICY_TYPE_IS_INVALID, policyType);
 248         }
 249         return policyTypeDefinition;
 250     }
 251
 252     private List<PropertyDataDefinition> validateFillPolicyProperties(PolicyTypeDefinition policyTypeDefinition,
 253             Map<String, Object> policyTemplateJsonMap) {
 254         if (MapUtils.isEmpty(policyTemplateJsonMap) || Objects.isNull(policyTypeDefinition)) {
 255             return Collections.emptyList();
 256         }
 257         List<PropertyDataDefinition> propertyDataDefinitionList = new ArrayList<>();
 258         Map<String, Object> propertiesMap =
 259                 (Map<String, Object>) policyTemplateJsonMap.get(PROPERTIES.getElementName());
 260         if (MapUtils.isEmpty(propertiesMap)) {
 261             return Collections.emptyList();
 262         }
 263         if (CollectionUtils.isNotEmpty(policyTypeDefinition.getProperties())) {
 264             propertyDataDefinitionList = policyTypeDefinition
 265                                                  .getProperties()
 266                                                  .stream()
 267                                                  .map(propertyDefinition -> setPropertyValue(propertiesMap,
 268                                                          propertyDefinition))
 269                                                  .collect(Collectors.toList());
 270         }
 271         return propertyDataDefinitionList;
 272     }
 273
 274     private PropertyDataDefinition setPropertyValue(Map<String, Object> propertiesMap, PropertyDataDefinition srcPropertyDataDefinition) {
 275         PropertyDataDefinition newPropertyDef = new PropertyDataDefinition(srcPropertyDataDefinition);
 276         String propertyName = newPropertyDef.getName();
 277         if (Objects.nonNull(propertiesMap.get(propertyName))) {
 278             Object propValue = propertiesMap.get(propertyName);
 279             newPropertyDef.setValue(PropertiesUtils.trimQuotes(gson.toJson(propValue)));
 280         }
 281         return newPropertyDef;
 282     }
 283
 284     private Map<PolicyTargetType, List<String>> validateFillPolicyTargets(Map<String, Object> policyTemplateJson,
 285         Map<String, Object> nodeTemplatesJson, Map<String, Object> groupTemplateJson) {
 286         Map<PolicyTargetType, List<String>> targets = new EnumMap<>(PolicyTargetType.class);
 287         if (policyTemplateJson.containsKey(TARGETS.getElementName())
 288                     && policyTemplateJson.get(TARGETS.getElementName()) instanceof List ) {
 289             List<String> targetsElement = (List<String>) policyTemplateJson.get(TARGETS.getElementName());
 290             targets.put(PolicyTargetType.COMPONENT_INSTANCES, targetsElement.stream().filter(nodeTemplatesJson::containsKey).collect(toList()));
 291             targets.put(PolicyTargetType.GROUPS, targetsElement.stream().filter(groupTemplateJson::containsKey).collect(toList()));
 292         }
 293         return targets;
 294     }
 295
 296     private Map<String, UploadComponentInstanceInfo> getInstances(String yamlName, Map<String, Object> toscaJson, Map<String, String> createdNodesToscaResourceNames) {
 297
 298         Map<String, Object> nodeTemlates = findFirstToscaMapElement(toscaJson, NODE_TEMPLATES)
 299                 .left()
 300                 .on(err -> failIfNoNodeTemplates(yamlName));
 301
 302         return getInstances(toscaJson, createdNodesToscaResourceNames, nodeTemlates);
 303     }
 304
 305     private Map<String, UploadComponentInstanceInfo> getInstances(Map<String, Object> toscaJson, Map<String, String> createdNodesToscaResourceNames, Map<String, Object> nodeTemlates) {
 306         Map<String, UploadComponentInstanceInfo> moduleComponentInstances;
 307         Map<String, Object> substitutionMappings = getSubstitutionMappings(toscaJson);
 308         moduleComponentInstances = nodeTemlates.entrySet()
 309                 .stream()
 310                 .map(node -> buildModuleComponentInstanceInfo(node, substitutionMappings, createdNodesToscaResourceNames))
 311                 .collect(Collectors.toMap(UploadComponentInstanceInfo::getName, i -> i));
 312         return moduleComponentInstances;
 313     }
 314
 315     private Map<String, Object> getSubstitutionMappings(Map<String, Object> toscaJson) {
 316         Map<String, Object> substitutionMappings = null;
 317         Either<Map<String, Object>, ResultStatusEnum> eitherSubstitutionMappings = findFirstToscaMapElement(toscaJson, SUBSTITUTION_MAPPINGS);
 318         if (eitherSubstitutionMappings.isLeft()) {
 319             substitutionMappings = eitherSubstitutionMappings.left().value();
 320         }
 321         return substitutionMappings;
 322     }
 323
 324     @SuppressWarnings("unchecked")
 325     private Map<String, GroupDefinition> getGroups(String fileName, Map<String, Object> toscaJson) {
 326
 327         Map<String, Object> foundGroups = findFirstToscaMapElement(toscaJson, GROUPS)
 328                 .left()
 329                 .on(err -> logGroupsNotFound(fileName));
 330
 331         if (MapUtils.isNotEmpty(foundGroups)) {
 332             Map<String, GroupDefinition> groups = foundGroups
 333                     .entrySet()
 334                     .stream()
 335                     .map(this::createGroup)
 336                     .collect(Collectors.toMap(GroupDefinition::getName, g -> g));
 337             Map<String, Object> substitutionMappings = getSubstitutionMappings(toscaJson);
 338             if (capabilitiesSubstitutionMappingsExist(substitutionMappings)) {
 339                 groups.entrySet().forEach(entry -> updateCapabilitiesNames(entry.getValue(), getNamesToUpdate(entry.getKey(),
 340                         (Map<String, List<String>>) substitutionMappings.get(CAPABILITIES.getElementName()))));
 341             }
 342             return groups;
 343         }
 344         return new HashMap<>();
 345     }
 346
 347     private Map<String, Object> logGroupsNotFound(String fileName) {
 348         log.debug("#logGroupsNotFound - Groups were not found in the yaml template {}.", fileName);
 349         return new HashMap<>();
 350     }
 351
 352     private void updateCapabilitiesNames(GroupDefinition group, Map<String, String> capabilityNames) {
 353         if (MapUtils.isNotEmpty(group.getCapabilities())) {
 354             group.getCapabilities().values()
 355                     .stream()
 356                     .flatMap(Collection::stream)
 357                     .filter(cap -> capabilityNames.containsKey(cap.getName()))
 358                     .forEach(cap -> cap.setName(capabilityNames.get(cap.getName())));
 359         }
 360     }
 361
 362     private Map<String, String> getNamesToUpdate(String name, Map<String, List<String>> pair) {
 363         return pair.entrySet().stream()
 364                 .filter(e -> e.getValue().get(SUB_MAPPING_CAPABILITY_OWNER_NAME_IDX).equalsIgnoreCase(name))
 365                 .collect(Collectors.toMap(e -> e.getValue().get(SUB_MAPPING_CAPABILITY_NAME_IDX), Map.Entry::getKey,  (n1 ,n2) -> n1));
 366     }
 367
 368     private boolean capabilitiesSubstitutionMappingsExist(Map<String, Object> substitutionMappings) {
 369         return substitutionMappings != null && substitutionMappings.containsKey(CAPABILITIES.getElementName());
 370     }
 371
 372     private GroupDefinition createGroup(Map.Entry<String, Object> groupNameValue) {
 373         GroupDefinition group = new GroupDefinition();
 374         group.setName(groupNameValue.getKey());
 375         try {
 376             if (groupNameValue.getValue() != null && groupNameValue.getValue() instanceof Map) {
 377                 Map<String, Object> groupTemplateJsonMap = (Map<String, Object>) groupNameValue.getValue();
 378                 validateAndFillGroup(group, groupTemplateJsonMap);
 379                 validateUpdateGroupProperties(group, groupTemplateJsonMap);
 380                 validateUpdateGroupCapabilities(group, groupTemplateJsonMap);
 381             } else {
 382                 rollbackWithException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
 383             }
 384         } catch (ClassCastException e) {
 385             log.debug("#createGroup - Failed to create the group {}. The exception occure", groupNameValue.getKey(), e);
 386             rollbackWithException(ActionStatus.INVALID_YAML);
 387         }
 388         return group;
 389     }
 390
 391     private Map<String, CapabilityDefinition> addCapabilities(Map<String, CapabilityDefinition> cap, Map<String, CapabilityDefinition> otherCap) {
 392         cap.putAll(otherCap);
 393         return cap;
 394     }
 395
 396     private Map<String, CapabilityDefinition> addCapability(CapabilityDefinition cap) {
 397         Map<String, CapabilityDefinition> map = Maps.newHashMap();
 398         map.put(cap.getName(), cap);
 399         return map;
 400     }
 401
 402     private void setMembers(GroupDefinition groupInfo, Map<String, Object> groupTemplateJsonMap) {
 403         if (groupTemplateJsonMap.containsKey(MEMBERS.getElementName())) {
 404             Object members = groupTemplateJsonMap.get(MEMBERS.getElementName());
 405             if (members != null) {
 406                 if (members instanceof List) {
 407                     setMembersFromList(groupInfo, (List<?>) members);
 408                 } else {
 409                     log.debug("The 'members' member is not of type list under group {}", groupInfo.getName());
 410                     rollbackWithException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
 411                 }
 412             }
 413         }
 414     }
 415
 416     private void setMembersFromList(GroupDefinition groupInfo, List<?> membersAsList) {
 417         groupInfo.setMembers(membersAsList
 418                 .stream()
 419                 .collect(Collectors.toMap(Object::toString, member -> "")));
 420     }
 421
 422     @SuppressWarnings("unchecked")
 423     private void validateUpdateGroupProperties(GroupDefinition groupInfo, Map<String, Object> groupTemplateJsonMap) {
 424         if (groupTemplateJsonMap.containsKey(PROPERTIES.getElementName())) {
 425             Object propertiesElement = groupTemplateJsonMap.get(PROPERTIES.getElementName());
 426             if (propertiesElement instanceof Map){
 427                 mergeGroupProperties(groupInfo, (Map<String, Object>) propertiesElement);
 428             }
 429         }
 430     }
 431
 432     private void mergeGroupProperties(GroupDefinition groupInfo, Map<String, Object> parsedProperties) {
 433         if(CollectionUtils.isNotEmpty(groupInfo.getProperties())){
 434             validateGroupProperties(parsedProperties, groupInfo);
 435             groupInfo.getProperties().forEach(p -> mergeGroupProperty(p, parsedProperties));
 436         }
 437     }
 438
 439     private void mergeGroupProperty(PropertyDataDefinition property, Map<String, Object> parsedProperties) {
 440         if(parsedProperties.containsKey(property.getName())){
 441             Object propValue = parsedProperties.get(property.getName());
 442             if (valueNotContainsPattern(propertyValuePattern, propValue)) {
 443                 setPropertyValueAndGetInputsValues(property, propValue);
 444             }
 445         }
 446     }
 447
 448     private void setPropertyValueAndGetInputsValues(PropertyDataDefinition property, Object propValue) {
 449         if(propValue != null){
 450             UploadPropInfo uploadPropInfo = buildProperty(property.getName(), propValue);
 451             property.setValue(convertPropertyValue(ToscaPropertyType.isValidType(property.getType()), uploadPropInfo.getValue()));
 452             property.setGetInputValues(uploadPropInfo.getGet_input());
 453         }
 454     }
 455
 456     private String convertPropertyValue(ToscaPropertyType type, Object value) {
 457         String convertedValue = null;
 458         if (value != null) {
 459             if (type == null || value instanceof Map || value instanceof List) {
 460                 convertedValue = gson.toJson(value);
 461             } else {
 462                 convertedValue = value.toString();
 463             }
 464         }
 465         return convertedValue;
 466     }
 467
 468     private void setDescription(GroupDefinition groupInfo, Map<String, Object> groupTemplateJsonMap) {
 469         if (groupTemplateJsonMap.containsKey(DESCRIPTION.getElementName())) {
 470             groupInfo.setDescription(
 471                     (String) groupTemplateJsonMap.get(DESCRIPTION.getElementName()));
 472         }
 473     }
 474
 475     private void validateAndFillGroup(GroupDefinition groupInfo, Map<String, Object> groupTemplateJsonMap) {
 476         String type = (String) groupTemplateJsonMap.get(TYPE.getElementName());
 477         if(StringUtils.isEmpty(type)){
 478             log.debug("#validateAndFillGroup - The 'type' member is not found under group {}", groupInfo.getName());
 479             rollbackWithException(ActionStatus.GROUP_MISSING_GROUP_TYPE, groupInfo.getName());
 480         }
 481         groupInfo.setType(type);
 482         GroupTypeDefinition groupType =  groupTypeBusinessLogic.getLatestGroupTypeByType(type);
 483         if (groupType == null) {
 484             log.debug("#validateAndFillGroup - The group type {} not found", groupInfo.getName());
 485             rollbackWithException(ActionStatus.GROUP_TYPE_IS_INVALID, type);
 486         }
 487         groupInfo.convertFromGroupProperties(groupType.getProperties());
 488         groupInfo.convertCapabilityDefinitions(groupType.getCapabilities());
 489         setDescription(groupInfo, groupTemplateJsonMap);
 490         setMembers(groupInfo, groupTemplateJsonMap);
 491     }
 492
 493     @SuppressWarnings("unchecked")
 494     private void validateUpdateGroupCapabilities(GroupDefinition groupInfo, Map<String, Object> groupTemplateJsonMap) {
 495
 496         if (groupTemplateJsonMap.containsKey(CAPABILITIES.getElementName())) {
 497             Object capabilities = groupTemplateJsonMap.get(CAPABILITIES.getElementName());
 498             if (capabilities instanceof List) {
 499                 validateUpdateCapabilities(groupInfo, ((List<Object>) capabilities).stream()
 500                         .map(o -> buildGroupCapability(groupInfo, o))
 501                         .collect(Collectors.toMap(CapabilityDefinition::getType, this::addCapability, this::addCapabilities)));
 502             } else if (capabilities instanceof Map) {
 503                 validateUpdateCapabilities(groupInfo, ((Map<String, Object>) capabilities).entrySet()
 504                         .stream()
 505                         .map(e -> buildGroupCapability(groupInfo, e))
 506                         .collect(Collectors.toMap(CapabilityDefinition::getType, this::addCapability, this::addCapabilities)));
 507             } else {
 508                 log.debug("#setCapabilities - Failed to import the capabilities of the group {}. ", groupInfo.getName());
 509                 rollbackWithException(ActionStatus.INVALID_YAML);
 510             }
 511         }
 512     }
 513
 514     private void validateUpdateCapabilities(GroupDefinition groupInfo, Map<String, Map<String, CapabilityDefinition>> capabilityInfo) {
 515         validateGroupCapabilities(groupInfo, capabilityInfo);
 516         groupInfo.updateCapabilitiesProperties(capabilityInfo);
 517     }
 518
 519     private void validateGroupCapabilities(GroupDefinition group, Map<String, Map<String, CapabilityDefinition>> parsedCapabilities) {
 520         if (MapUtils.isNotEmpty(parsedCapabilities)) {
 521             if (MapUtils.isEmpty(group.getCapabilities())) {
 522                 failOnMissingCapabilityTypes(group, Lists.newArrayList(parsedCapabilities.keySet()));
 523             }
 524             List<String> missingCapTypes = parsedCapabilities.keySet().stream().filter(ct -> !group.getCapabilities().containsKey(ct)).collect(toList());
 525             if (CollectionUtils.isNotEmpty(missingCapTypes)) {
 526                 failOnMissingCapabilityTypes(group, missingCapTypes);
 527             }
 528             group.getCapabilities().entrySet().forEach(e -> validateCapabilities(group, e.getValue(), parsedCapabilities.get(e.getKey())));
 529         }
 530     }
 531
 532     private void validateCapabilities(GroupDefinition group, List<CapabilityDefinition> capabilities, Map<String, CapabilityDefinition> parsedCapabilities) {
 533         List<String> allowedCapNames = capabilities.stream().map(CapabilityDefinition::getName).distinct().collect(toList());
 534         List<String> missingCapNames = parsedCapabilities.keySet().stream().filter(c -> !allowedCapNames.contains(c)).collect(toList());
 535         if (CollectionUtils.isNotEmpty(missingCapNames)) {
 536             failOnMissingCapabilityNames(group, missingCapNames);
 537         }
 538         validateCapabilitiesProperties(capabilities, parsedCapabilities);
 539     }
 540
 541     private void validateCapabilitiesProperties(List<CapabilityDefinition> capabilities, Map<String, CapabilityDefinition> parsedCapabilities) {
 542         capabilities.forEach(c -> validateCapabilityProperties(c, parsedCapabilities.get(c.getName())));
 543     }
 544
 545     private void validateCapabilityProperties(CapabilityDefinition capability, CapabilityDefinition parsedCapability) {
 546         if(parsedCapability != null && parsedCapability.getProperties() != null){
 547             List<String> parsedPropertiesNames = parsedCapability.getProperties()
 548                 .stream()
 549                 .map(ComponentInstanceProperty::getName).collect(toList());
 550             validateProperties(capability.getProperties().stream().map(PropertyDataDefinition::getName).collect(toList()), parsedPropertiesNames, ActionStatus.PROPERTY_NOT_FOUND, capability.getName(), capability.getType());
 551         }
 552     }
 553
 554     private void  validateGroupProperties(Map<String, Object> parsedProperties, GroupDefinition groupInfo) {
 555         List<String> parsedPropertiesNames = parsedProperties.entrySet()
 556                         .stream()
 557                         .map(Map.Entry::getKey).collect(toList());
 558         validateProperties(groupInfo.getProperties().stream().map(PropertyDataDefinition::getName).collect(toList()), parsedPropertiesNames, ActionStatus.GROUP_PROPERTY_NOT_FOUND, groupInfo.getName(), groupInfo.getType());
 559     }
 560
 561     private void validateProperties(List<String> validProperties, List<String> parsedProperties, ActionStatus actionStatus, String name, String type) {
 562         if (CollectionUtils.isNotEmpty(parsedProperties)) {
 563             verifyMissingProperties(actionStatus, name, type, parsedProperties
 564                     .stream()
 565                     .filter(n -> !validProperties.contains(n))
 566                     .collect(toList()));
 567         }
 568     }
 569
 570     private void verifyMissingProperties(ActionStatus actionStatus, String name, String type, List<String> missingProperties) {
 571         if (CollectionUtils.isNotEmpty(missingProperties)) {
 572             log.debug("#validateProperties - Failed to validate properties. The properties {} are missing on {} of the type {}. ", missingProperties.toString(), name, type);
 573             rollbackWithException(actionStatus, missingProperties.toString(), missingProperties.toString(), name, type);
 574         }
 575     }
 576
 577     @SuppressWarnings("unchecked")
 578     private CapabilityDefinition buildGroupCapability(GroupDefinition groupInfo, Object capObject) {
 579         if (!(capObject instanceof Map)) {
 580             log.debug("#convertToGroupCapability - Failed to import the capability {}. ", capObject);
 581             rollbackWithException(ActionStatus.INVALID_YAML);
 582         }
 583         return buildGroupCapability(groupInfo, ((Map<String, Object>) capObject).entrySet().iterator().next());
 584     }
 585
 586     @SuppressWarnings("unchecked")
 587     private CapabilityDefinition buildGroupCapability(GroupDefinition groupInfo, Map.Entry<String, Object> capEntry) {
 588         CapabilityDefinition capability = new CapabilityDefinition();
 589         capability.setOwnerType(CapabilityDataDefinition.OwnerType.GROUP);
 590         capability.setName(capEntry.getKey());
 591         capability.setParentName(capEntry.getKey());
 592         capability.setOwnerId(groupInfo.getName());
 593         if (!(capEntry.getValue() instanceof Map)) {
 594             log.debug("#convertMapEntryToCapabilityDefinition - Failed to import the capability {}. ", capEntry.getKey());
 595             rollbackWithException(ActionStatus.INVALID_YAML);
 596         }
 597         Map<String, Object> capabilityValue = (Map<String, Object>) capEntry.getValue();
 598         String type = (String) capabilityValue.get(TYPE.getElementName());
 599         if (StringUtils.isEmpty(type)) {
 600             log.debug("#convertMapEntryToCapabilityDefinition - Failed to import the capability {}. Missing capability type. ", capEntry.getKey());
 601             rollbackWithException(ActionStatus.INVALID_YAML);
 602         }
 603         capability.setType(type);
 604         if (!(capabilityValue.get(PROPERTIES.getElementName()) instanceof Map)) {
 605             log.debug("#convertMapEntryToCapabilityDefinition - Failed to import the capability {}. ", capEntry.getKey());
 606             rollbackWithException(ActionStatus.INVALID_YAML);
 607         }
 608         Map<String, Object> properties = (Map<String, Object>) capabilityValue.get(PROPERTIES.getElementName());
 609         capability.setProperties(properties.entrySet().stream().map(this::convertToProperty).collect(toList()));
 610         return capability;
 611     }
 612
 613     private ComponentInstanceProperty convertToProperty(Map.Entry<String, Object> e) {
 614         ComponentInstanceProperty property = new ComponentInstanceProperty();
 615         property.setName(e.getKey());
 616         property.setValue((String) e.getValue());
 617         return property;
 618     }
 619
 620     @SuppressWarnings("unchecked")
 621     private UploadComponentInstanceInfo buildModuleComponentInstanceInfo(
 622             Map.Entry<String, Object> nodeTemplateJsonEntry, Map<String, Object> substitutionMappings,
 623             Map<String, String> createdNodesToscaResourceNames) {
 624
 625         UploadComponentInstanceInfo nodeTemplateInfo = new UploadComponentInstanceInfo();
 626         nodeTemplateInfo.setName(nodeTemplateJsonEntry.getKey());
 627         try {
 628             if (nodeTemplateJsonEntry.getValue() instanceof String) {
 629                 String nodeTemplateJsonString = (String) nodeTemplateJsonEntry.getValue();
 630                 nodeTemplateInfo.setType(nodeTemplateJsonString);
 631             } else if (nodeTemplateJsonEntry.getValue() instanceof Map) {
 632                 Map<String, Object> nodeTemplateJsonMap = (Map<String, Object>) nodeTemplateJsonEntry.getValue();
 633                 setToscaResourceType(createdNodesToscaResourceNames, nodeTemplateInfo, nodeTemplateJsonMap);
 634                 setRequirements(nodeTemplateInfo, nodeTemplateJsonMap);
 635                 setCapabilities(nodeTemplateInfo, nodeTemplateJsonMap);
 636                 setArtifacts(nodeTemplateInfo, nodeTemplateJsonMap);
 637                 updateProperties(nodeTemplateInfo, nodeTemplateJsonMap);
 638                 setDirectives(nodeTemplateInfo, nodeTemplateJsonMap);
 639                 setNodeFilter(nodeTemplateInfo, nodeTemplateJsonMap);
 640                 setSubstitutions(substitutionMappings, nodeTemplateInfo);
 641             } else {
 642                 rollbackWithException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
 643             }
 644         } catch (ClassCastException e) {
 645             BeEcompErrorManager.getInstance().logBeSystemError("Import Resource - create capability");
 646             log.debug("error when creating capability, message:{}", e.getMessage(), e);
 647             rollbackWithException(ActionStatus.INVALID_YAML);
 648         }
 649         return nodeTemplateInfo;
 650     }
 651
 652     @SuppressWarnings("unchecked")
 653     private void setSubstitutions(Map<String, Object> substitutionMappings, UploadComponentInstanceInfo nodeTemplateInfo) {
 654         if (substitutionMappings != null) {
 655             if (substitutionMappings.containsKey(CAPABILITIES.getElementName())) {
 656                 nodeTemplateInfo.setCapabilitiesNamesToUpdate(getNamesToUpdate(nodeTemplateInfo.getName(), (Map<String, List<String>>) substitutionMappings
 657                         .get(CAPABILITIES.getElementName())));
 658             }
 659             if (substitutionMappings.containsKey(REQUIREMENTS.getElementName())) {
 660                 nodeTemplateInfo.setRequirementsNamesToUpdate(getNamesToUpdate(
 661                         nodeTemplateInfo.getName(), (Map<String, List<String>>) substitutionMappings
 662                                 .get(REQUIREMENTS.getElementName())));
 663             }
 664         }
 665     }
 666
 667     private void updateProperties(UploadComponentInstanceInfo nodeTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
 668         if (nodeTemplateJsonMap.containsKey(PROPERTIES.getElementName())) {
 669             Map<String, List<UploadPropInfo>> properties = buildPropModuleFromYaml(nodeTemplateJsonMap);
 670             if (!properties.isEmpty()) {
 671                 nodeTemplateInfo.setProperties(properties);
 672             }
 673         }
 674     }
 675
 676     private void setCapabilities(UploadComponentInstanceInfo nodeTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
 677         if (nodeTemplateJsonMap.containsKey(CAPABILITIES.getElementName())) {
 678             Map<String, List<UploadCapInfo>> eitherCapRes = createCapModuleFromYaml(nodeTemplateJsonMap);
 679             if (!eitherCapRes.isEmpty()) {
 680                 nodeTemplateInfo.setCapabilities(eitherCapRes);
 681             }
 682         }
 683     }
 684
 685     private void setArtifacts(UploadComponentInstanceInfo nodeTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
 686         if (nodeTemplateJsonMap.containsKey(ARTIFACTS.getElementName())) {
 687             Map<String, Map<String, UploadArtifactInfo>> eitherArtifactsRes = createArtifactsModuleFromYaml(nodeTemplateJsonMap);
 688             if (!eitherArtifactsRes.isEmpty()) {
 689                 nodeTemplateInfo.setArtifacts(eitherArtifactsRes);
 690             }
 691         }
 692     }
 693
 694     private void setRequirements(UploadComponentInstanceInfo nodeTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
 695         if (nodeTemplateJsonMap.containsKey(REQUIREMENTS.getElementName())) {
 696             Map<String, List<UploadReqInfo>> regResponse = createReqModuleFromYaml(nodeTemplateJsonMap);
 697             if (!regResponse.isEmpty()) {
 698                 nodeTemplateInfo.setRequirements(regResponse);
 699             }
 700         }
 701     }
 702
 703     private void setToscaResourceType(Map<String, String> createdNodesToscaResourceNames,
 704                                       UploadComponentInstanceInfo nodeTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
 705         if (nodeTemplateJsonMap.containsKey(TYPE.getElementName())) {
 706             String toscaResourceType = (String) nodeTemplateJsonMap.get(TYPE.getElementName());
 707             if (createdNodesToscaResourceNames.containsKey(toscaResourceType)) {
 708                 toscaResourceType = createdNodesToscaResourceNames.get(toscaResourceType);
 709             }
 710             nodeTemplateInfo.setType(toscaResourceType);
 711         }
 712     }
 713
 714     private void setDirectives(UploadComponentInstanceInfo nodeTemplateInfo,
 715             Map<String, Object> nodeTemplateJsonMap) {
 716         List<String> directives =
 717                 (List<String>) nodeTemplateJsonMap.get(TypeUtils.ToscaTagNamesEnum.DIRECTIVES.getElementName());
 718         nodeTemplateInfo.setDirectives(directives);
 719     }
 720
 721     private void setNodeFilter(UploadComponentInstanceInfo nodeTemplateInfo,
 722             Map<String, Object> nodeTemplateJsonMap) {
 723         if (nodeTemplateJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.NODE_FILTER.getElementName())) {
 724             nodeTemplateInfo.setUploadNodeFilterInfo(
 725                     new NodeFilterUploadCreator().createNodeFilterData(nodeTemplateJsonMap.get(
 726                             TypeUtils.ToscaTagNamesEnum.NODE_FILTER.getElementName())));
 727         }
 728     }
 729
 730     @SuppressWarnings("unchecked")
 731     private Map<String, List<UploadReqInfo>> createReqModuleFromYaml(Map<String, Object> nodeTemplateJsonMap) {
 732         Map<String, List<UploadReqInfo>> moduleRequirements = new HashMap<>();
 733         Either<List<Object>, ResultStatusEnum> requirementsListRes =
 734                 findFirstToscaListElement(nodeTemplateJsonMap, REQUIREMENTS);
 735
 736         if (requirementsListRes.isLeft()) {
 737             for (Object jsonReqObj : requirementsListRes.left().value()) {
 738                 String reqName = ((Map<String, Object>) jsonReqObj).keySet().iterator().next();
 739                 Object reqJson = ((Map<String, Object>) jsonReqObj).get(reqName);
 740                 addModuleNodeTemplateReq(moduleRequirements, reqJson, reqName);
 741             }
 742         } else {
 743             Either<Map<String, Object>, ResultStatusEnum> requirementsMapRes =
 744                     findFirstToscaMapElement(nodeTemplateJsonMap, REQUIREMENTS);
 745             if (requirementsMapRes.isLeft()) {
 746                 for (Map.Entry<String, Object> entry : requirementsMapRes.left().value().entrySet()) {
 747                     String reqName = entry.getKey();
 748                     Object reqJson = entry.getValue();
 749                     addModuleNodeTemplateReq(moduleRequirements, reqJson, reqName);
 750                 }
 751             }
 752         }
 753         return moduleRequirements;
 754     }
 755
 756     private void addModuleNodeTemplateReq(Map<String, List<UploadReqInfo>> moduleRequirements, Object requirementJson, String requirementName) {
 757
 758         UploadReqInfo requirement = buildModuleNodeTemplateReg(requirementJson);
 759         requirement.setName(requirementName);
 760         if (moduleRequirements.containsKey(requirementName)) {
 761             moduleRequirements.get(requirementName).add(requirement);
 762         } else {
 763             List<UploadReqInfo> list = new ArrayList<>();
 764             list.add(requirement);
 765             moduleRequirements.put(requirementName, list);
 766         }
 767     }
 768
 769     @SuppressWarnings("unchecked")
 770     private Map<String, Map<String, UploadArtifactInfo>> createArtifactsModuleFromYaml(Map<String, Object> nodeTemplateJsonMap) {
 771         Map<String, Map<String, UploadArtifactInfo>> moduleArtifacts = new HashMap<>();
 772         Either<List<Object>, ResultStatusEnum> ArtifactsListRes =
 773                 findFirstToscaListElement(nodeTemplateJsonMap, ARTIFACTS);
 774         if (ArtifactsListRes.isLeft()) {
 775             for (Object jsonArtifactObj : ArtifactsListRes.left().value()) {
 776                 String key = ((Map<String, Object>) jsonArtifactObj).keySet().iterator().next();
 777                 Object artifactJson = ((Map<String, Object>) jsonArtifactObj).get(key);
 778                 addModuleNodeTemplateArtifacts(moduleArtifacts, artifactJson, key);
 779             }
 780         } else {
 781             Either<Map<String, Map<String, Object>>, ResultStatusEnum> ArtifactsMapRes =
 782                     findFirstToscaMapElement(nodeTemplateJsonMap, ARTIFACTS);
 783             if (ArtifactsMapRes.isLeft()) {
 784                 for (Map.Entry<String, Map<String, Object>> entry : ArtifactsMapRes.left().value().entrySet()) {
 785                     String artifactName = entry.getKey();
 786                     Object artifactJson = entry.getValue();
 787                     addModuleNodeTemplateArtifacts(moduleArtifacts, artifactJson, artifactName);
 788                 }
 789             }
 790         }
 791         return moduleArtifacts;
 792     }
 793
 794     private void addModuleNodeTemplateArtifacts(Map<String, Map<String, UploadArtifactInfo>> moduleArtifacts, Object artifactJson, String artifactName) {
 795
 796         UploadArtifactInfo artifact = buildModuleNodeTemplateArtifact(artifactJson);
 797         artifact.setName(artifactName);
 798         if (moduleArtifacts.containsKey(ARTIFACTS.getElementName())) {
 799             moduleArtifacts.get(ARTIFACTS.getElementName()).put(artifactName, artifact);
 800         } else {
 801             Map<String, UploadArtifactInfo> map = new HashMap<>();
 802             map.put(artifactName, artifact);
 803             moduleArtifacts.put(ARTIFACTS.getElementName(), map);
 804         }
 805     }
 806
 807     @SuppressWarnings("unchecked")
 808     private UploadArtifactInfo buildModuleNodeTemplateArtifact(Object artifactObject) {
 809         UploadArtifactInfo artifactTemplateInfo = new UploadArtifactInfo();
 810         if (artifactObject instanceof Map) {
 811             fillArtifact(artifactTemplateInfo, (Map<String, Object>) artifactObject);
 812         }
 813         return artifactTemplateInfo;
 814     }
 815
 816     private void fillArtifact(UploadArtifactInfo artifactTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
 817         if (nodeTemplateJsonMap.containsKey(TYPE.getElementName())) {
 818             artifactTemplateInfo.setType((String) nodeTemplateJsonMap.get(TYPE.getElementName()));
 819         }
 820         if (nodeTemplateJsonMap.containsKey(FILE.getElementName())) {
 821             artifactTemplateInfo.setFile((String) nodeTemplateJsonMap.get(FILE.getElementName()));
 822         }
 823     }
 824
 825
 826     @SuppressWarnings("unchecked")
 827     private Map<String, List<UploadCapInfo>> createCapModuleFromYaml(Map<String, Object> nodeTemplateJsonMap) {
 828         Map<String, List<UploadCapInfo>> moduleCap = new HashMap<>();
 829         Either<List<Object>, ResultStatusEnum> capabilitiesListRes =
 830                 findFirstToscaListElement(nodeTemplateJsonMap, CAPABILITIES);
 831         if (capabilitiesListRes.isLeft()) {
 832             for (Object jsonCapObj : capabilitiesListRes.left().value()) {
 833                 String key = ((Map<String, Object>) jsonCapObj).keySet().iterator().next();
 834                 Object capJson = ((Map<String, Object>) jsonCapObj).get(key);
 835                 addModuleNodeTemplateCap(moduleCap, capJson, key);
 836             }
 837         } else {
 838             Either<Map<String, Object>, ResultStatusEnum> capabilitiesMapRes =
 839                     findFirstToscaMapElement(nodeTemplateJsonMap, CAPABILITIES);
 840             if (capabilitiesMapRes.isLeft()) {
 841                 for (Map.Entry<String, Object> entry : capabilitiesMapRes.left().value().entrySet()) {
 842                     String capName = entry.getKey();
 843                     Object capJson = entry.getValue();
 844                     addModuleNodeTemplateCap(moduleCap, capJson, capName);
 845                 }
 846             }
 847         }
 848         return moduleCap;
 849     }
 850
 851     private void addModuleNodeTemplateCap(Map<String, List<UploadCapInfo>> moduleCap, Object capJson, String key) {
 852
 853         UploadCapInfo capabilityDef = buildModuleNodeTemplateCap(capJson);
 854         capabilityDef.setKey(key);
 855         if (moduleCap.containsKey(key)) {
 856             moduleCap.get(key).add(capabilityDef);
 857         } else {
 858             List<UploadCapInfo> list = new ArrayList<>();
 859             list.add(capabilityDef);
 860             moduleCap.put(key, list);
 861         }
 862     }
 863
 864     @SuppressWarnings("unchecked")
 865     private UploadCapInfo buildModuleNodeTemplateCap(Object capObject) {
 866         UploadCapInfo capTemplateInfo = new UploadCapInfo();
 867
 868         if (capObject instanceof String) {
 869             String nodeTemplateJsonString = (String) capObject;
 870             capTemplateInfo.setNode(nodeTemplateJsonString);
 871         } else if (capObject instanceof Map) {
 872             fillCapability(capTemplateInfo, (Map<String, Object>) capObject);
 873         }
 874         return capTemplateInfo;
 875     }
 876
 877     private void fillCapability(UploadCapInfo capTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
 878         if (nodeTemplateJsonMap.containsKey(NODE.getElementName())) {
 879             capTemplateInfo.setNode((String) nodeTemplateJsonMap.get(NODE.getElementName()));
 880         }
 881         if (nodeTemplateJsonMap.containsKey(TYPE.getElementName())) {
 882             capTemplateInfo.setType((String) nodeTemplateJsonMap.get(TYPE.getElementName()));
 883         }
 884         if (nodeTemplateJsonMap.containsKey(VALID_SOURCE_TYPES.getElementName())) {
 885             Either<List<Object>, ResultStatusEnum> validSourceTypesRes =
 886                     findFirstToscaListElement(nodeTemplateJsonMap, VALID_SOURCE_TYPES);
 887             if (validSourceTypesRes.isLeft()) {
 888                 capTemplateInfo.setValidSourceTypes(validSourceTypesRes.left().value().stream()
 889                         .map(Object::toString).collect(toList()));
 890             }
 891         }
 892         if (nodeTemplateJsonMap.containsKey(PROPERTIES.getElementName())) {
 893             Map<String, List<UploadPropInfo>> props = buildPropModuleFromYaml(nodeTemplateJsonMap);
 894             if (!props.isEmpty()) {
 895                 List<UploadPropInfo> properties = props.values().stream().flatMap(Collection::stream).collect(toList());
 896                 capTemplateInfo.setProperties(properties);
 897             }
 898         }
 899     }
 900
 901     @SuppressWarnings("unchecked")
 902     private UploadReqInfo buildModuleNodeTemplateReg(Object regObject) {
 903
 904         UploadReqInfo regTemplateInfo = new UploadReqInfo();
 905         if (regObject instanceof String) {
 906             String nodeTemplateJsonString = (String) regObject;
 907             regTemplateInfo.setNode(nodeTemplateJsonString);
 908         } else if (regObject instanceof Map) {
 909             Map<String, Object> nodeTemplateJsonMap = (Map<String, Object>) regObject;
 910             if (nodeTemplateJsonMap.containsKey(NODE.getElementName())) {
 911                 regTemplateInfo.setNode((String) nodeTemplateJsonMap.get(NODE.getElementName()));
 912             }
 913             if (nodeTemplateJsonMap.containsKey(CAPABILITY.getElementName())) {
 914                 regTemplateInfo.setCapabilityName(
 915                         (String) nodeTemplateJsonMap.get(CAPABILITY.getElementName()));
 916             }
 917         }
 918         return regTemplateInfo;
 919     }
 920
 921     private Map<String, List<UploadPropInfo>> buildPropModuleFromYaml(Map<String, Object> nodeTemplateJsonMap) {
 922
 923         Map<String, List<UploadPropInfo>> moduleProp = new HashMap<>();
 924         Either<Map<String, Object>, ResultStatusEnum> toscaProperties =
 925                 findFirstToscaMapElement(nodeTemplateJsonMap, PROPERTIES);
 926         if (toscaProperties.isLeft()) {
 927             Map<String, Object> jsonProperties = toscaProperties.left().value();
 928             for (Map.Entry<String, Object> jsonPropObj : jsonProperties.entrySet()) {
 929                 if (valueNotContainsPattern(propertyValuePattern, jsonPropObj.getValue())) {
 930                     addProperty(moduleProp, jsonPropObj);
 931                 }
 932             }
 933         }
 934         return moduleProp;
 935     }
 936
 937     private void addProperty(Map<String, List<UploadPropInfo>> moduleProp, Map.Entry<String, Object> jsonPropObj) {
 938         UploadPropInfo propertyDef = buildProperty(jsonPropObj.getKey(), jsonPropObj.getValue());
 939         if (moduleProp.containsKey(propertyDef.getName())) {
 940             moduleProp.get(propertyDef.getName()).add(propertyDef);
 941         } else {
 942             List<UploadPropInfo> list = new ArrayList<>();
 943             list.add(propertyDef);
 944             moduleProp.put(propertyDef.getName(), list);
 945         }
 946     }
 947
 948     @SuppressWarnings("unchecked")
 949     private UploadPropInfo buildProperty(String propName, Object propValue) {
 950
 951         UploadPropInfo propertyDef = new UploadPropInfo();
 952         propertyDef.setValue(propValue);
 953         propertyDef.setName(propName);
 954         if (propValue instanceof Map) {
 955             if (((Map<String, Object>) propValue).containsKey(TYPE.getElementName())) {
 956                 propertyDef.setType(((Map<String, Object>) propValue)
 957                         .get(TYPE.getElementName()).toString());
 958             }
 959             if (containsGetInput(propValue)) {
 960                 fillInputRecursively(propName, (Map<String, Object>) propValue, propertyDef);
 961             }
 962
 963             if (((Map<String, Object>) propValue).containsKey(DESCRIPTION.getElementName())) {
 964                 propertyDef.setDescription(((Map<String, Object>) propValue)
 965                         .get(DESCRIPTION.getElementName()).toString());
 966             }
 967             if (((Map<String, Object>) propValue)
 968                     .containsKey(DEFAULT_VALUE.getElementName())) {
 969                 propertyDef.setValue(((Map<String, Object>) propValue)
 970                         .get(DEFAULT_VALUE.getElementName()));
 971             }
 972             if (((Map<String, Object>) propValue).containsKey(IS_PASSWORD.getElementName())) {
 973                 propertyDef.setPassword(Boolean.getBoolean(((Map<String, Object>) propValue)
 974                         .get(IS_PASSWORD.getElementName()).toString()));
 975             } else {
 976                 propertyDef.setValue(propValue);
 977             }
 978         } else if (propValue instanceof List) {
 979             List<Object> propValueList = (List<Object>) propValue;
 980
 981             fillInputsListRecursively(propertyDef, propValueList);
 982             propertyDef.setValue(propValue);
 983         }
 984
 985         return propertyDef;
 986     }
 987
 988     @SuppressWarnings("unchecked")
 989     private boolean containsGetInput(Object propValue) {
 990         return ((Map<String, Object>) propValue).containsKey(GET_INPUT.getElementName())
 991                 || ImportUtils.containsGetInput(propValue);
 992     }
 993
 994     @SuppressWarnings("unchecked")
 995     private void fillInputsListRecursively(UploadPropInfo propertyDef, List<Object> propValueList) {
 996         for (Object objValue : propValueList) {
 997
 998             if (objValue instanceof Map) {
 999                 Map<String, Object> objMap = (Map<String, Object>) objValue;
1000                 if (objMap.containsKey(GET_INPUT.getElementName())) {
1001                     fillInputRecursively(propertyDef.getName(), objMap, propertyDef);
1002                 } else {
1003                     Set<String> keys = objMap.keySet();
1004                     findAndFillInputsListRecursively(propertyDef, objMap, keys);
1005                 }
1006             } else if (objValue instanceof List) {
1007                 List<Object> propSubValueList = (List<Object>) objValue;
1008                 fillInputsListRecursively(propertyDef, propSubValueList);
1009             }
1010         }
1011     }
1012
1013     @SuppressWarnings("unchecked")
1014     private void findAndFillInputsListRecursively(UploadPropInfo propertyDef, Map<String, Object> objMap,
1015                                                   Set<String> keys) {
1016         for (String key : keys) {
1017             Object value = objMap.get(key);
1018             if (value instanceof Map) {
1019                 fillInputRecursively(key, (Map<String, Object>) value, propertyDef);
1020             } else if (value instanceof List) {
1021                 List<Object> propSubValueList = (List<Object>) value;
1022                 fillInputsListRecursively(propertyDef, propSubValueList);
1023             }
1024         }
1025     }
1026
1027     private void fillInputRecursively(String propName, Map<String, Object> propValue, UploadPropInfo propertyDef) {
1028
1029         if (propValue.containsKey(GET_INPUT.getElementName())) {
1030             Object getInput = propValue.get(GET_INPUT.getElementName());
1031             GetInputValueDataDefinition getInputInfo = new GetInputValueDataDefinition();
1032             List<GetInputValueDataDefinition> getInputs = propertyDef.getGet_input();
1033             if (getInputs == null) {
1034                 getInputs = new ArrayList<>();
1035             }
1036             if (getInput instanceof String) {
1037
1038                 getInputInfo.setInputName((String) getInput);
1039                 getInputInfo.setPropName(propName);
1040
1041             } else if (getInput instanceof List) {
1042                 fillInput(propName, getInput, getInputInfo);
1043             }
1044             getInputs.add(getInputInfo);
1045             propertyDef.setGet_input(getInputs);
1046             propertyDef.setValue(propValue);
1047         } else {
1048             findAndFillInputRecursively(propValue, propertyDef);
1049         }
1050     }
1051
1052     @SuppressWarnings("unchecked")
1053     private void findAndFillInputRecursively(Map<String, Object> propValue, UploadPropInfo propertyDef) {
1054         for (String propName : propValue.keySet()) {
1055             Object value = propValue.get(propName);
1056             if (value instanceof Map) {
1057                 fillInputRecursively(propName, (Map<String, Object>) value, propertyDef);
1058
1059             } else if (value instanceof List) {
1060                 fillInputsRecursively(propertyDef, propName, (List<Object>) value);
1061             }
1062         }
1063     }
1064
1065     private void fillInputsRecursively(UploadPropInfo propertyDef, String propName, List<Object> inputs) {
1066         inputs.stream()
1067                 .filter(o -> o instanceof Map)
1068                 .forEach(o -> fillInputRecursively(propName, (Map<String, Object>)o, propertyDef));
1069     }
1070
1071     @SuppressWarnings("unchecked")
1072     private void fillInput(String propName, Object getInput, GetInputValueDataDefinition getInputInfo) {
1073         List<Object> getInputList = (List<Object>) getInput;
1074         getInputInfo.setPropName(propName);
1075         getInputInfo.setInputName((String) getInputList.get(0));
1076         if (getInputList.size() > 1) {
1077             Object indexObj = getInputList.get(1);
1078             if (indexObj instanceof Integer) {
1079                 getInputInfo.setIndexValue((Integer) indexObj);
1080             } else if (indexObj instanceof Float) {
1081                 int index = ((Float) indexObj).intValue();
1082                 getInputInfo.setIndexValue(index);
1083             } else if (indexObj instanceof Map && ((Map<String, Object>) indexObj)
1084                     .containsKey(GET_INPUT.getElementName())) {
1085                 Object index = ((Map<String, Object>) indexObj)
1086                         .get(GET_INPUT.getElementName());
1087                 GetInputValueDataDefinition getInputInfoIndex = new GetInputValueDataDefinition();
1088                 getInputInfoIndex.setInputName((String) index);
1089                 getInputInfoIndex.setPropName(propName);
1090                 getInputInfo.setGetInputIndex(getInputInfoIndex);
1091             }
1092             getInputInfo.setList(true);
1093         }
1094     }
1095
1096     private boolean valueNotContainsPattern(Pattern pattern, Object propValue) {
1097         return propValue == null || !pattern.matcher(propValue.toString()).find();
1098     }
1099
1100     private Map<String, Object> failIfNoNodeTemplates(String fileName) {
1101         janusGraphDao.rollback();
1102         throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, fileName);
1103     }
1104
1105     private Object failIfNotTopologyTemplate(String fileName) {
1106         janusGraphDao.rollback();
1107         throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, fileName);
1108     }
1109
1110     private void rollbackWithException(ActionStatus actionStatus, String... params) {
1111         janusGraphDao.rollback();
1112         throw new ByActionStatusComponentException(actionStatus, params);
1113     }
1114
1115     private void failOnMissingCapabilityTypes(GroupDefinition groupDefinition, List<String> missingCapTypes) {
1116         log.debug("#failOnMissingCapabilityTypes - Failed to validate the capabilities of the group {}. The capability types {} are missing on the group type {}. ", groupDefinition.getName(), missingCapTypes.toString(), groupDefinition.getType());
1117         if(CollectionUtils.isNotEmpty(missingCapTypes)) {
1118             rollbackWithException(ActionStatus.MISSING_CAPABILITY_TYPE, missingCapTypes.toString());
1119         }
1120     }
1121
1122     private void failOnMissingCapabilityNames(GroupDefinition groupDefinition, List<String> missingCapNames) {
1123         log.debug("#failOnMissingCapabilityNames - Failed to validate the capabilities of the group {}. The capabilities with the names {} are missing on the group type {}. ", groupDefinition.getName(), missingCapNames.toString(), groupDefinition.getType());
1124         rollbackWithException(ActionStatus.MISSING_CAPABILITIES, missingCapNames.toString(), CapabilityDataDefinition.OwnerType.GROUP.getValue(), groupDefinition.getName());
1125     }
1126
1127 }