vid-app-common/src/main/java/org/onap/vid/asdc/parser/ToscaParserImpl2.java

   1 package org.onap.vid.asdc.parser;
   2
   3 import org.apache.commons.collections.CollectionUtils;
   4 import org.apache.commons.lang3.StringUtils;
   5 import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
   6 import org.onap.sdc.tosca.parser.enums.FilterType;
   7 import org.onap.sdc.tosca.parser.enums.SdcTypes;
   8 import org.onap.sdc.tosca.parser.exceptions.SdcToscaParserException;
   9 import org.onap.sdc.tosca.parser.impl.SdcToscaParserFactory;
  10 import org.onap.sdc.toscaparser.api.Group;
  11 import org.onap.sdc.toscaparser.api.*;
  12 import org.onap.sdc.toscaparser.api.elements.Metadata;
  13 import org.onap.sdc.toscaparser.api.parameters.Input;
  14 import org.onap.vid.asdc.beans.Service;
  15 import org.onap.vid.model.*;
  16
  17 import java.nio.file.Path;
  18 import java.util.*;
  19
  20 import static java.util.stream.Collectors.toList;
  21 import static java.util.stream.Collectors.toMap;
  22 import static org.onap.vid.asdc.parser.ToscaParserImpl2.Constants.VF_MODULE_LABEL;
  23
  24 public class ToscaParserImpl2 {
  25
  26
  27     private final VidNotionsBuilder vidNotionsBuilder;
  28
  29     public class Constants {
  30         public static final String UUID = "UUID";
  31         public static final String DESCRIPTION = "description";
  32         public static final String SERVICE_TYPE = "serviceType";
  33         public static final String SERVICE_ROLE = "serviceRole";
  34         public static final String ECOMP_GENERATED_NAMING = "ecompGeneratedNaming";
  35
  36         public static final String CUSTOMIZATION_UUID = "customizationUUID";
  37         public static final String VF_MODULE_MODEL_VERSION = "vfModuleModelVersion";
  38         public static final String VF_MODULE_MODEL_CUSTOMIZATION_UUID = "vfModuleModelCustomizationUUID";
  39         public static final String VOLUME_GROUP = "volume_group";
  40         public static final String VF_MODULE_MODEL_INVARIANT_UUID = "vfModuleModelInvariantUUID";
  41         public static final String VF_MODULE_MODEL_UUID = "vfModuleModelUUID";
  42         public static final String INVARIANT_UUID = "invariantUUID";
  43         public static final String VERSION = "version";
  44         public static final String NAME = "name";
  45         public static final String CATEGORY = "category";
  46         public static final String VF_MODULE_MODEL_NAME = "vfModuleModelName";
  47         public static final String GET_INPUT = "get_input";
  48         public static final String TYPE = "type";
  49
  50         public static final String INSTANTIATION_TYPE = "instantiationType";
  51         //instantiation type
  52         public static final String BOTH = "Both";
  53         public static final String MACRO = "Macro";
  54         public static final String A_LA_CARTE = "A-La-Carte";
  55         public static final String CLIENT_CONFIG = "ClientConfig";
  56
  57         //service role
  58         public static final String GROUPING = "GROUPING";
  59
  60         //group properties
  61         public static final String MIN_VF_MODULE_INSTANCES = "min_vf_module_instances";
  62         public static final String MAX_VF_MODULE_INSTANCES = "max_vf_module_instances";
  63         public static final String INITIAL_COUNT = "initial_count";
  64         public static final String VF_MODULE_LABEL = "vf_module_label";
  65         public static final String VF_MODULE_TYPE = "vf_module_type";
  66
  67         //collection resource properties
  68         public static final String SUBCATEGORY = "subcategory";
  69         public static final String RESOURCE_VENDOR = "resourceVendor";
  70         public static final String RESOURCE_VENDOR_RELEASE = "resourceVendorRelease";
  71         public static final String RESOURCE_VENDOR_MODEL_NUMBER = "resourceVendorModelNumber";
  72         public static final String ORG_OPENECOMP_GROUPS_NETWORK_COLLECTION = "org.openecomp.groups.NetworkCollection";
  73         public static final String NETWORK_COLLECTION_FUNCTION = "network_collection_function";
  74         public static final String NETWORK_COLLECTION_DESCRIPTION = "network_collection_description";
  75
  76         //vfc instance group properties
  77         public static final String VFC_INSTANCE_GROUP_TYPE = "org.openecomp.groups.VfcInstanceGroup";
  78         public static final String VFC_PARENT_PORT_ROLE = "vfc_parent_port_role";
  79         public static final String SUBINTERFACE_ROLE = "subinterface_role";
  80         public static final String VFC_INSTANCE_GROUP_FUNCTION = "vfc_instance_group_function";
  81
  82         public static final String FABRIC_CONFIGURATION_TYPE = "org.openecomp.nodes.FabricConfiguration";
  83
  84         public static final String RESOURCE_GROUP_TYPE = "org.openecomp.groups.ResourceInstanceGroup";
  85         public static final String RESOURCE_GROUP_CONTAINED_TYPE = "contained_resource_type";
  86
  87         public static final String VNF_GROUP = "VnfGroup";
  88
  89         public static final String NAMING_POLICY_TYPE = "org.openecomp.policies.External";
  90
  91         public static final String ECOMP_GENERATED_NAMING_PROPERTY = "ecomp_generated_naming";
  92     }
  93
  94     public ToscaParserImpl2(VidNotionsBuilder vidNotionsBuilder) {
  95         this.vidNotionsBuilder = vidNotionsBuilder;
  96     }
  97
  98     public ServiceModel makeServiceModel(Path path, Service asdcServiceMetadata) throws SdcToscaParserException {
  99         ServiceModel serviceModel = new ServiceModel();
 100         ISdcCsarHelper sdcCsarHelper = getSdcCsarHelper(path);
 101         List<String> policiesTargets = extractNamingPoliciesTargets(sdcCsarHelper);
 102
 103         serviceModel.setService(extractServiceFromCsar(asdcServiceMetadata, sdcCsarHelper));
 104         serviceModel.setVolumeGroups(extractVolumeGroups(sdcCsarHelper));
 105         serviceModel.setVfModules(extractVfModuleFromCsar(sdcCsarHelper));
 106         serviceModel.setVnfs(extractVnfsFromCsar(sdcCsarHelper, policiesTargets));
 107         serviceModel.setConfigurations(extractPortMirroringConfigFromCsar(sdcCsarHelper, policiesTargets));
 108         serviceModel.setServiceProxies(extractServiceProxyFromCsar(sdcCsarHelper, policiesTargets));
 109         serviceModel.setNetworks(extractNetworksFromCsar(sdcCsarHelper, policiesTargets));
 110         serviceModel.setPnfs(extractPnfsFromCsar(sdcCsarHelper, policiesTargets));
 111         serviceModel.setCollectionResource(extractCRFromCsar(sdcCsarHelper, policiesTargets));
 112         serviceModel.setFabricConfigurations(extractFabricConfigFromCsar(sdcCsarHelper, policiesTargets));
 113         serviceModel.setVnfGroups(extractVnfGroupsFromCsar(sdcCsarHelper, policiesTargets));
 114         serviceModel.getService().setVidNotions(vidNotionsBuilder.buildVidNotions(sdcCsarHelper, serviceModel));
 115         return serviceModel;
 116     }
 117
 118     public ISdcCsarHelper getSdcCsarHelper(Path path) throws SdcToscaParserException {
 119         SdcToscaParserFactory factory = SdcToscaParserFactory.getInstance();
 120         return factory.getSdcCsarHelper(path.toFile().getAbsolutePath(), false);
 121     }
 122
 123     private org.onap.vid.model.Service extractServiceFromCsar(Service asdcServiceMetadata, ISdcCsarHelper csarHelper) {
 124         org.onap.vid.model.Service service = new org.onap.vid.model.Service();
 125
 126         service.setName(csarHelper.getServiceMetadata().getValue(Constants.NAME));
 127         service.setCategory(csarHelper.getServiceMetadata().getValue(Constants.CATEGORY));
 128         service.setInvariantUuid(csarHelper.getServiceMetadata().getValue(Constants.INVARIANT_UUID));
 129         service.setUuid(csarHelper.getServiceMetadata().getValue(Constants.UUID));
 130         service.setVersion(asdcServiceMetadata.getVersion());
 131         service.setDescription(csarHelper.getServiceMetadata().getValue(Constants.DESCRIPTION));
 132         service.setInputs(inputsListToInputsMap(csarHelper.getInputsWithAnnotations()));
 133         service.setServiceEcompNaming(isUserProvidingServiceNameOptional(csarHelper));
 134         service.setServiceType(csarHelper.getServiceMetadata().getValue(Constants.SERVICE_TYPE));
 135         service.setServiceRole(csarHelper.getServiceMetadata().getValue(Constants.SERVICE_ROLE));
 136         service.setInstantiationType(validateInstantiationType(csarHelper));
 137         return service;
 138     }
 139
 140     private String isUserProvidingServiceNameOptional(ISdcCsarHelper csarHelper) {
 141         return ToscaNamingPolicy.isUserProvidingServiceNameOptional(csarHelper);
 142     }
 143
 144     private Map<String, CR> extractCRFromCsar(ISdcCsarHelper sdcCsarHelper, List<String> policiesTargets) {
 145         List<NodeTemplate> nodeTemplates = sdcCsarHelper.getServiceNodeTemplates();
 146         Map<String, CR> collectionResourceMap = new HashMap<>();
 147
 148         for (NodeTemplate nodeTemplate : nodeTemplates) {
 149             if ( nodeTemplate.getMetaData().getValue(Constants.TYPE).equals(SdcTypes.CR.getValue()) ) {
 150                 CR cr = new CR();
 151                 populateCrFromNodeTemplate(nodeTemplate, sdcCsarHelper, cr, policiesTargets);
 152                 collectionResourceMap.put(nodeTemplate.getName(), cr);
 153             }
 154         }
 155
 156         return collectionResourceMap;
 157     }
 158
 159     private Map<String, Node> extractFabricConfigFromCsar(ISdcCsarHelper sdcCsarHelper, List<String> policiesTargets) {
 160         List<NodeTemplate> nodeTemplates = sdcCsarHelper.getServiceNodeTemplates();
 161         Map<String, Node> fabricConfiguration = new HashMap<>();
 162
 163         for (NodeTemplate nodeTemplate : nodeTemplates) {
 164             List<NodeTemplate> nodeTemplateChildren = sdcCsarHelper.getNodeTemplateChildren(nodeTemplate);
 165             for (NodeTemplate nodeTemplateChild : nodeTemplateChildren) {
 166                 if ( nodeTemplateChild.getType().equals(Constants.FABRIC_CONFIGURATION_TYPE) ) {
 167                     Node node = new Node();
 168                     fabricConfiguration.put(nodeTemplateChild.getName(), populateNodeFromNodeTemplate(nodeTemplateChild, sdcCsarHelper, node, policiesTargets));
 169                 }
 170             }
 171
 172         }
 173         return fabricConfiguration;
 174     }
 175
 176
 177     private void populateCrFromNodeTemplate(NodeTemplate nodeTemplate, ISdcCsarHelper sdcCsarHelper, CR cr, List<String> policiesTargets) {
 178         populateNodeFromNodeTemplate(nodeTemplate, sdcCsarHelper, cr, policiesTargets);
 179         cr.setCustomizationUUID(nodeTemplate.getMetaData().getValue(Constants.CUSTOMIZATION_UUID));
 180         cr.setCategory(nodeTemplate.getMetaData().getValue(Constants.CATEGORY));
 181         cr.setSubcategory(nodeTemplate.getMetaData().getValue(Constants.SUBCATEGORY));
 182         cr.setResourceVendor(nodeTemplate.getMetaData().getValue(Constants.RESOURCE_VENDOR));
 183         cr.setResourceVendorRelease(nodeTemplate.getMetaData().getValue(Constants.RESOURCE_VENDOR_RELEASE));
 184         cr.setResourceVendorModelNumber(nodeTemplate.getMetaData().getValue(Constants.RESOURCE_VENDOR_MODEL_NUMBER));
 185         cr.setNetworksCollection(getNetworksCollectionMapFromGroupsList(sdcCsarHelper, nodeTemplate));
 186     }
 187
 188     private Map<String, NetworkCollection> getNetworksCollectionMapFromGroupsList(ISdcCsarHelper sdcCsarHelper, NodeTemplate nodeTemplate) {
 189         List<Group> groups = sdcCsarHelper.getGroupsOfOriginOfNodeTemplateByToscaGroupType(nodeTemplate, Constants.ORG_OPENECOMP_GROUPS_NETWORK_COLLECTION);
 190         Map<String, NetworkCollection> networksCollectionMap = new HashMap<>();
 191         for (Group group : groups) {
 192             networksCollectionMap.put(group.getName(), populateCollectionNetworkFromGroup(group, nodeTemplate));
 193         }
 194         return networksCollectionMap;
 195     }
 196
 197     private NetworkCollection populateCollectionNetworkFromGroup(Group group, NodeTemplate nodeTemplate) {
 198         NetworkCollection networkCollection = new NetworkCollection();
 199         networkCollection.setUuid(group.getMetadata().getValue(Constants.UUID));
 200         networkCollection.setInvariantUuid(group.getMetadata().getValue(Constants.INVARIANT_UUID));
 201         networkCollection.setVersion(group.getMetadata().getValue(Constants.VERSION));
 202         networkCollection.setName(group.getMetadata().getValue(Constants.NAME));
 203         extractPropertiesOfCollectionNetworkFromCsar(group, nodeTemplate, networkCollection);
 204
 205         return networkCollection;
 206     }
 207
 208     private void extractPropertiesOfCollectionNetworkFromCsar(Group group, NodeTemplate nodeTemplate, NetworkCollection networkCollection) {
 209         LinkedHashMap<String, Property> properties = group.getProperties();
 210         Map<String, Property> nodeTemplateProperties = nodeTemplate.getProperties();
 211
 212         String networkCollectionFunction = (String) ((Map) (properties.get(Constants.NETWORK_COLLECTION_FUNCTION).getValue())).get(Constants.GET_INPUT);
 213         String networkCollectionDescription = (String) ((Map) (properties.get(Constants.NETWORK_COLLECTION_DESCRIPTION).getValue())).get(Constants.GET_INPUT);
 214
 215         networkCollection.getNetworkCollectionProperties().setNetworkCollectionDescription((String) nodeTemplateProperties.get(networkCollectionDescription).getValue());
 216         networkCollection.getNetworkCollectionProperties().setNetworkCollectionFunction((String) nodeTemplateProperties.get(networkCollectionFunction).getValue());
 217     }
 218
 219
 220     private Map<String, VNF> extractVnfsFromCsar(ISdcCsarHelper csarHelper, List<String> policiesTargets) {
 221         List<NodeTemplate> nodeTemplates = csarHelper.getServiceVfList();
 222         Map<String, VNF> vnfsMaps = new HashMap<>();
 223
 224         for (NodeTemplate nodeTemplate : nodeTemplates) {
 225             VNF vnf = new VNF();
 226             populateNodeFromNodeTemplate(nodeTemplate, csarHelper, vnf, policiesTargets);
 227             vnf.setModelCustomizationName(nodeTemplate.getName());
 228             vnf.setVfModules(getVfModulesFromVF(csarHelper, vnf.getCustomizationUuid()));
 229             vnf.setVolumeGroups(getVolumeGroupsFromVF(csarHelper, vnf.getCustomizationUuid()));
 230             vnf.setVfcInstanceGroups(getVfcInstanceGroup(csarHelper, nodeTemplate));
 231             if (ToscaNamingPolicy.getEcompNamingValueForNode(nodeTemplate, "nf_naming").equals("true")) {
 232                 setEcompNamingProperty(vnf.getProperties(), "true");
 233             }
 234             vnfsMaps.put(nodeTemplate.getName(), vnf);
 235         }
 236         return vnfsMaps;
 237     }
 238
 239     private Map<String, VfcInstanceGroup> getVfcInstanceGroup(ISdcCsarHelper csarHelper, NodeTemplate nodeTemplate) {
 240         List<Group> vfcList = csarHelper.getGroupsOfOriginOfNodeTemplateByToscaGroupType(nodeTemplate, Constants.VFC_INSTANCE_GROUP_TYPE);
 241         return vfcList.stream()
 242                 .collect(toMap(Group::getName, group -> populateVfcInstanceGroupFromGroup(group, nodeTemplate)));
 243     }
 244
 245     private VfcInstanceGroup populateVfcInstanceGroupFromGroup(Group group, NodeTemplate nodeTemplate) {
 246         VfcInstanceGroup vfcInstanceGroup = new VfcInstanceGroup();
 247         vfcInstanceGroup.setUuid(group.getMetadata().getValue(Constants.UUID));
 248         vfcInstanceGroup.setInvariantUuid(group.getMetadata().getValue(Constants.INVARIANT_UUID));
 249         vfcInstanceGroup.setVersion(group.getMetadata().getValue(Constants.VERSION));
 250         vfcInstanceGroup.setName(group.getMetadata().getValue(Constants.NAME));
 251         vfcInstanceGroup.setVfcInstanceGroupProperties(getVfcPropertiesFromGroup(nodeTemplate, group));
 252
 253         return vfcInstanceGroup;
 254
 255     }
 256
 257     private VfcInstanceGroupProperties getVfcPropertiesFromGroup(NodeTemplate nodeTemplate, Group group) {
 258         VfcInstanceGroupProperties vfcInstanceGroupProperties = new VfcInstanceGroupProperties();
 259         vfcInstanceGroupProperties.setVfcParentPortRole((String) group.getProperties().get(Constants.VFC_PARENT_PORT_ROLE).getValue());
 260         vfcInstanceGroupProperties.setSubinterfaceRole((String) group.getProperties().get(Constants.SUBINTERFACE_ROLE).getValue());
 261
 262         String networkCollectionFunction = (String) ((Map) (group.getProperties().get(Constants.NETWORK_COLLECTION_FUNCTION).getValue())).get(Constants.GET_INPUT);
 263         String vfcInstanceGroupFunction = (String) ((Map) (group.getProperties().get(Constants.VFC_INSTANCE_GROUP_FUNCTION).getValue())).get(Constants.GET_INPUT);
 264
 265         if ( nodeTemplate.getProperties().get(networkCollectionFunction) != null )
 266             vfcInstanceGroupProperties.setNetworkCollectionFunction((String) nodeTemplate.getProperties().get(networkCollectionFunction).getValue());
 267         if ( nodeTemplate.getProperties().get(vfcInstanceGroupFunction) != null )
 268             vfcInstanceGroupProperties.setVfcInstanceGroupFunction((String) nodeTemplate.getProperties().get(vfcInstanceGroupFunction).getValue());
 269
 270         return vfcInstanceGroupProperties;
 271     }
 272
 273     private Map<String, PortMirroringConfig> extractPortMirroringConfigFromCsar(ISdcCsarHelper csarHelper, List<String> policiesTargets) {
 274         List<NodeTemplate> nodeTemplates = csarHelper.getServiceNodeTemplateBySdcType(SdcTypes.CONFIGURATION);//TODO change to
 275         Map<String, PortMirroringConfig> configMaps = new HashMap<>();
 276
 277         for (NodeTemplate nodeTemplate : nodeTemplates) {
 278             PortMirroringConfig pmConfig = new PortMirroringConfig();
 279             populateNodeFromNodeTemplate(nodeTemplate, csarHelper, pmConfig, policiesTargets);
 280
 281             pmConfig.setModelCustomizationName(nodeTemplate.getName());
 282             pmConfig.setRequirementAssignments(nodeTemplate.getRequirements());
 283             setSourceAndCollectorProxyNodes(csarHelper, pmConfig, nodeTemplate);
 284
 285             configMaps.put(nodeTemplate.getName(), pmConfig);
 286         }
 287
 288         return configMaps;
 289     }
 290
 291     private Map<String, ServiceProxy> extractServiceProxyFromCsar(ISdcCsarHelper csarHelper, List<String> policiesTargets) {
 292         List<NodeTemplate> nodeTemplates = csarHelper.getServiceNodeTemplateBySdcType(SdcTypes.SERVICE_PROXY);
 293         return nodeTemplates.stream()
 294                 .collect(toMap(NodeTemplate::getName, node -> getServiceProxyFromNodeTemplate(node, csarHelper, policiesTargets)));
 295     }
 296
 297     private ServiceProxy getServiceProxyFromNodeTemplate(NodeTemplate nodeTemplate, ISdcCsarHelper csarHelper, List<String> policiesTargets) {
 298         ServiceProxy serviceProxy = new ServiceProxy();
 299         populateNodeFromNodeTemplate(nodeTemplate, csarHelper, serviceProxy, policiesTargets);
 300
 301         Map<String, String> metadata = nodeTemplate.getMetaData().getAllProperties();
 302         serviceProxy.setSourceModelUuid(metadata.get("sourceModelUuid"));
 303         serviceProxy.setSourceModelInvariant(metadata.get("sourceModelInvariant"));
 304         serviceProxy.setSourceModelName(metadata.get("sourceModelName"));
 305
 306         return serviceProxy;
 307     }
 308
 309     private void setSourceAndCollectorProxyNodes(ISdcCsarHelper csarHelper, PortMirroringConfig portMirroringConfig, NodeTemplate nodeTemplate) {
 310         RequirementAssignments requirementAssignments = nodeTemplate.getRequirements();
 311
 312         List<String> sourceNodes = getRequirementsNodesNames(requirementAssignments.getRequirementsByName("source").getAll());
 313         portMirroringConfig.setSourceNodes(sourceNodes);
 314
 315         List<String> collectorNodes = getRequirementsNodesNames(requirementAssignments.getRequirementsByName("collector").getAll());
 316         if ( !collectorNodes.isEmpty() ) { // vprobe
 317             portMirroringConfig.setCollectorNodes(collectorNodes);
 318         } else { // pprobe - configuration by policy
 319             String collectorNodeName = csarHelper.getNodeTemplatePropertyLeafValue(nodeTemplate, "collector_node");
 320             if ( collectorNodeName != null ) {
 321                 portMirroringConfig.setCollectorNodes(Arrays.asList(collectorNodeName));
 322                 portMirroringConfig.setConfigurationByPolicy(true);
 323             }
 324         }
 325     }
 326
 327     private List<String> getRequirementsNodesNames(List<RequirementAssignment> requirements) {
 328
 329         List<String> requirementsNodes = new ArrayList<>();
 330         if ( !CollectionUtils.isEmpty(requirements) ) {
 331             requirementsNodes = requirements.stream().map(RequirementAssignment::getNodeTemplateName).collect(toList());
 332         }
 333
 334         return requirementsNodes;
 335     }
 336
 337     Map<String, VfModule> getVfModulesFromVF(ISdcCsarHelper csarHelper, String vfUuid) {
 338         List<Group> vfModulesByVf = csarHelper.getVfModulesByVf(vfUuid);
 339         return vfModulesByVf.stream()
 340                 .collect(toMap(Group::getName, group -> populateVfModuleFromGroup(group, csarHelper)));
 341     }
 342
 343     Map<String, VolumeGroup> getVolumeGroupsFromVF(ISdcCsarHelper csarHelper, String vfCustomizationUuid) {
 344         List<Group> vfModulesByVf = csarHelper.getVfModulesByVf(vfCustomizationUuid);
 345         return vfModulesByVf.stream()
 346                 .filter((group -> isVolumeGroup(group)))
 347                 .collect(toMap(Group::getName, group -> populateVolumeGroupFromGroup(group, csarHelper)));
 348     }
 349
 350     private static Boolean isVolumeGroup(Group group) {
 351         return Boolean.valueOf(group.getPropertyValue(Constants.VOLUME_GROUP).toString());
 352     }
 353
 354     private Map<String, Network> extractNetworksFromCsar(ISdcCsarHelper csarHelper, List<String> policiesTargets) {
 355         List<NodeTemplate> nodeTemplates = csarHelper.getServiceVlList();
 356         Map<String, Network> networksMap = new HashMap<>();
 357
 358         for (NodeTemplate nodeTemplate : nodeTemplates) {
 359             Network newNetwork = new Network();
 360             populateNodeFromNodeTemplate(nodeTemplate, csarHelper, newNetwork, policiesTargets);
 361             newNetwork.setModelCustomizationName(nodeTemplate.getName());
 362             if (ToscaNamingPolicy.getEcompNamingValueForNode(nodeTemplate, "exVL_naming").equals("true")) {
 363                 setEcompNamingProperty(newNetwork.getProperties(), "true");
 364             }
 365             networksMap.put(nodeTemplate.getName(), newNetwork);
 366         }
 367         return networksMap;
 368     }
 369
 370     private Map<String, Node> extractPnfsFromCsar(ISdcCsarHelper csarHelper, List<String> policiesTargets) {
 371         List<NodeTemplate> nodeTemplates = csarHelper.getServiceNodeTemplateBySdcType(SdcTypes.PNF);
 372         HashMap<String, Node> pnfHashMap = new HashMap<>();
 373
 374         for (NodeTemplate nodeTemplate : nodeTemplates) {
 375             Node pnf = new Node();
 376             populateNodeFromNodeTemplate(nodeTemplate, csarHelper, pnf, policiesTargets);
 377             pnfHashMap.put(nodeTemplate.getName(), pnf);
 378         }
 379         return pnfHashMap;
 380     }
 381
 382     private Map<String, VfModule> extractVfModuleFromCsar(ISdcCsarHelper csarHelper) {
 383         List<NodeTemplate> serviceVfList = csarHelper.getServiceVfList();
 384         HashMap<String, VfModule> vfModuleHashMap = new HashMap<>();
 385
 386         for (NodeTemplate nodeTemplate : serviceVfList) {
 387             Map<String, VfModule> nodeTemplateVfModule =
 388                     getVfModulesFromVF(csarHelper, nodeTemplate.getMetaData().getValue(Constants.CUSTOMIZATION_UUID));
 389             vfModuleHashMap.putAll(nodeTemplateVfModule);
 390         }
 391         return vfModuleHashMap;
 392     }
 393
 394     private Map<String, VolumeGroup> extractVolumeGroups(ISdcCsarHelper csarHelper) {
 395         HashMap<String, VolumeGroup> volumeGroupHashMap = new HashMap<>();
 396         for (NodeTemplate nodeTemplate : csarHelper.getServiceVfList()) {
 397             Map<String, VolumeGroup> nodeTemplateVolumeGroups =
 398                     getVolumeGroupsFromVF(csarHelper, csarHelper.getNodeTemplateCustomizationUuid(nodeTemplate));
 399             volumeGroupHashMap.putAll(nodeTemplateVolumeGroups);
 400         }
 401         return volumeGroupHashMap;
 402     }
 403
 404     private Map<String, org.onap.vid.asdc.beans.tosca.Input> inputsListToInputsMap(List<org.onap.sdc.toscaparser.api.parameters.Input> inputList) {
 405         Map<String, org.onap.vid.asdc.beans.tosca.Input> inputs = new HashMap<>();
 406         for (org.onap.sdc.toscaparser.api.parameters.Input input : inputList) {
 407             //Set only inputs without annotation to the service level
 408             if ( input.getAnnotations() == null )
 409                 inputs.put(input.getName(), convertInput(input, new org.onap.vid.asdc.beans.tosca.Input(), null));
 410         }
 411         return inputs;
 412     }
 413
 414     private Node populateNodeFromNodeTemplate(NodeTemplate nodeTemplate, ISdcCsarHelper csarHelper, Node newNode, List<String> policiesTargets) {
 415         newNode.setCustomizationUuid(csarHelper.getNodeTemplateCustomizationUuid(nodeTemplate));
 416         newNode.setDescription(nodeTemplate.getMetaData().getValue(Constants.DESCRIPTION));
 417         newNode.setInvariantUuid(nodeTemplate.getMetaData().getValue(Constants.INVARIANT_UUID));
 418         newNode.setUuid(nodeTemplate.getMetaData().getValue(Constants.UUID));
 419         newNode.setName(nodeTemplate.getMetaData().getValue(Constants.NAME));
 420         newNode.setVersion(nodeTemplate.getMetaData().getValue(Constants.VERSION));
 421         newNode.setInputs(extractInputsAndCommandsForNodeTemplate(nodeTemplate, csarHelper, newNode));
 422         newNode.setType(nodeTemplate.getMetaData().getValue(Constants.TYPE));
 423         Map<String, String> propertiesMap = nodeTemplate.getPropertiesObjects().stream()
 424                 .collect(toMap(Property::getName, p -> p.getValue().toString()));
 425         setEcompNamingProperty(propertiesMap, String.valueOf(policiesTargets.contains(nodeTemplate.getName())));
 426         newNode.setProperties(propertiesMap);
 427         return newNode;
 428     }
 429
 430     private VfModule populateVfModuleFromGroup(Group group, ISdcCsarHelper csarHelper) {
 431         VfModule vfModule = new VfModule();
 432         extractBasicPropertiesForGroup(vfModule, group, csarHelper);
 433         vfModule.setVolumeGroupAllowed(isVolumeGroup(group));
 434         return vfModule;
 435     }
 436
 437     private VolumeGroup populateVolumeGroupFromGroup(Group group, ISdcCsarHelper csarHelper) {
 438         VolumeGroup volumeGroup = new VolumeGroup();
 439         extractBasicPropertiesForGroup(volumeGroup, group, csarHelper);
 440         return volumeGroup;
 441     }
 442
 443     private void extractBasicPropertiesForGroup(org.onap.vid.model.Group newGroup, Group group, ISdcCsarHelper csarHelper) {
 444         newGroup.setDescription(group.getDescription());
 445         newGroup.setVersion(group.getMetadata().getValue(Constants.VF_MODULE_MODEL_VERSION));
 446         newGroup.setCustomizationUuid(group.getMetadata().getValue(Constants.VF_MODULE_MODEL_CUSTOMIZATION_UUID));
 447         newGroup.setModelCustomizationName(group.getMetadata().getValue(Constants.VF_MODULE_MODEL_NAME));
 448         newGroup.setName(group.getMetadata().getValue(Constants.VF_MODULE_MODEL_NAME));
 449         newGroup.setUuid(group.getMetadata().getValue(Constants.VF_MODULE_MODEL_UUID));
 450         newGroup.setInvariantUuid(group.getMetadata().getValue(Constants.VF_MODULE_MODEL_INVARIANT_UUID));
 451         newGroup.setProperties(extractVfModuleProperties(group, csarHelper));
 452         newGroup.setInputs(extractVfInputsFromCsarByAnnotation(csarHelper, newGroup));
 453     }
 454
 455
 456     private Map<String, org.onap.vid.asdc.beans.tosca.Input> extractVfInputsFromCsarByAnnotation(ISdcCsarHelper csarHelper, org.onap.vid.model.Group group) {
 457         Map<String, org.onap.vid.asdc.beans.tosca.Input> inputMap = new HashMap<>();
 458         if ( group.getProperties().getVfModuleLabel() != null ) {
 459             List<Input> inputsList = csarHelper.getInputsWithAnnotations();
 460             for (Input input : inputsList) {
 461                 extractVfModuleInput(group, inputMap, input);
 462             }
 463         }
 464         return inputMap;
 465     }
 466
 467     private void extractVfModuleInput(org.onap.vid.model.Group group, Map<String, org.onap.vid.asdc.beans.tosca.Input> inputMap, Input input) {
 468         if ( input.getAnnotations() != null ) {
 469             List<Property> annotationProperties = input.getAnnotations().get("source").getProperties();
 470             if ( isInputMatchesToGroup(annotationProperties, group) ) {
 471                 final org.onap.vid.asdc.beans.tosca.Input vfModuleInput = new org.onap.vid.asdc.beans.tosca.Input(input, annotationProperties);
 472                 if ( vfModuleInput.getInputProperties() != null && vfModuleInput.getInputProperties().getParamName() != null ) {
 473                     inputMap.put(vfModuleInput.getInputProperties().getParamName(), vfModuleInput);
 474                 } else {
 475                     inputMap.put(input.getName(), vfModuleInput);
 476                 }
 477             }
 478         }
 479     }
 480
 481
 482     private boolean isInputMatchesToGroup(List<Property> annotationProperties, org.onap.vid.model.Group group) {
 483         for (Property property : annotationProperties) {
 484             if ( property.getName().equals(VF_MODULE_LABEL) ) {
 485                 final Object values = property.getValue();
 486                 final String vfModuleLabel = group.getProperties().getVfModuleLabel();
 487                 if ( values instanceof List ) {
 488                     if ( listContainsAsString((List) values, vfModuleLabel) ) return true;
 489                 } else {
 490                     return getPropertyValueAsString(property).equals(vfModuleLabel);
 491                 }
 492             }
 493         }
 494         return false;
 495     }
 496
 497     private boolean listContainsAsString(List list, String value) {
 498         for (Object v : list) {
 499             if ( StringUtils.equals(v.toString(), value) ) {
 500                 return true;
 501             }
 502         }
 503         return false;
 504     }
 505
 506     public String getPropertyValueAsString(Property property) {
 507         return removeSquareBrackets(property.getValue().toString());
 508     }
 509
 510     private String removeSquareBrackets(String stringWithSquareBrackets) {
 511         return stringWithSquareBrackets.replaceAll("(^\\[|\\]$)", "");
 512     }
 513
 514     private GroupProperties extractVfModuleProperties(Group group, ISdcCsarHelper csarHelper) {
 515         GroupProperties vfModuleProperties = new GroupProperties();
 516         if ( csarHelper.getGroupPropertyAsObject(group, Constants.MIN_VF_MODULE_INSTANCES) != null )
 517             vfModuleProperties.setMinCountInstances((Integer) csarHelper.getGroupPropertyAsObject(group, Constants.MIN_VF_MODULE_INSTANCES));
 518         if ( csarHelper.getGroupPropertyAsObject(group, Constants.MAX_VF_MODULE_INSTANCES) != null )
 519             vfModuleProperties.setMaxCountInstances((Integer) csarHelper.getGroupPropertyAsObject(group, Constants.MAX_VF_MODULE_INSTANCES));
 520         if ( csarHelper.getGroupPropertyAsObject(group, Constants.INITIAL_COUNT) != null )
 521             vfModuleProperties.setInitialCount((Integer) csarHelper.getGroupPropertyAsObject(group, Constants.INITIAL_COUNT));
 522         if ( csarHelper.getGroupPropertyAsObject(group, VF_MODULE_LABEL) != null )
 523             vfModuleProperties.setVfModuleLabel((String) csarHelper.getGroupPropertyAsObject(group, VF_MODULE_LABEL));
 524         vfModuleProperties.setBaseModule(isModuleTypeIsBaseObjectSafe(csarHelper.getGroupPropertyAsObject(group, Constants.VF_MODULE_TYPE)));
 525         return vfModuleProperties;
 526     }
 527
 528
 529     public static boolean isModuleTypeIsBaseObjectSafe(Object vfModuleTypeValue) {
 530         return (vfModuleTypeValue instanceof String) && (isModuleTypeIsBase((String) vfModuleTypeValue));
 531     }
 532
 533     protected static boolean isModuleTypeIsBase(String vfModuleTypeValue) {
 534         return "Base".equalsIgnoreCase(vfModuleTypeValue);
 535     }
 536
 537
 538     private Map<String, org.onap.vid.asdc.beans.tosca.Input> extractInputsAndCommandsForNodeTemplate(NodeTemplate nodeTemplate, ISdcCsarHelper csarHelper, Node newNode) {
 539         Map<String, org.onap.vid.asdc.beans.tosca.Input> inputMap = new HashMap<>();
 540         Map<String, CommandProperty> commandPropertyMap = new HashMap<>();
 541
 542         List<Input> inputs = csarHelper.getServiceInputs();
 543         Map<String, String> properties = csarHelper.filterNodeTemplatePropertiesByValue(nodeTemplate, FilterType.CONTAINS, Constants.GET_INPUT);
 544         for (Map.Entry<String, String> property : properties.entrySet()) {
 545             String inputKey = property.getValue();
 546             String key = extractInputValue(inputKey);
 547             for (Input input : inputs) {
 548                 if ( input.getName().equals(key) ) {
 549                     org.onap.vid.asdc.beans.tosca.Input localInput = new org.onap.vid.asdc.beans.tosca.Input();
 550                     localInput = convertInput(input, localInput, nodeTemplate);
 551                     String name = property.getKey();
 552                     commandPropertyMap.put(name, extractCommands(name, key));
 553                     inputMap.put(name, localInput);
 554                 }
 555             }
 556         }
 557         newNode.setCommands(commandPropertyMap);
 558         return inputMap;
 559     }
 560
 561     private String extractInputValue(String inputKey) {
 562         return inputKey.substring(inputKey.indexOf(':') + 1);
 563     }
 564
 565     private org.onap.vid.asdc.beans.tosca.Input convertInput(Input parserInput, org.onap.vid.asdc.beans.tosca.Input localInput, NodeTemplate nodeTemplate){
 566         localInput.setDefault(parserInput.getDefault());
 567         localInput.setDescription(parserInput.getDescription());
 568         localInput.setRequired(parserInput.isRequired());
 569         localInput.setType(parserInput.getType());
 570         localInput.setConstraints(parserInput.getConstraints());
 571 //        localInput.setentry_schema()
 572
 573         //if inputs of inner nodeTemplate - tell its details
 574         if(nodeTemplate != null) {
 575             Metadata metadata = nodeTemplate.getMetaData();
 576             localInput.setTemplateName(metadata.getValue("name"));
 577             localInput.setTemplateUUID(metadata.getValue("UUID"));
 578             localInput.setTemplateInvariantUUID(metadata.getValue("invariantUUID"));
 579             localInput.setTemplateCustomizationUUID(metadata.getValue("customizationUUID"));
 580         }
 581
 582         return localInput;
 583     }
 584
 585     private CommandProperty extractCommands(String displayName, String inputName) {
 586         CommandProperty commandProperty = new CommandProperty();
 587         commandProperty.setDisplayName(displayName);
 588         commandProperty.setCommand(Constants.GET_INPUT);
 589         commandProperty.setInputName(inputName);
 590         return commandProperty;
 591     }
 592
 593     private void setEcompNamingProperty(Map<String, String> propertiesMap, String isUserProvidingVnfNameOptional) {
 594         propertiesMap.put(Constants.ECOMP_GENERATED_NAMING_PROPERTY, isUserProvidingVnfNameOptional);
 595     }
 596
 597     private String validateInstantiationType(ISdcCsarHelper csarHelper){
 598         String instantiationType = csarHelper.getServiceMetadata().getValue(Constants.INSTANTIATION_TYPE);
 599         String validatedInstantiationType = Constants.CLIENT_CONFIG;
 600         if(instantiationType != null && !instantiationType.isEmpty()){
 601             if(instantiationType.equalsIgnoreCase(Constants.MACRO) || instantiationType.equalsIgnoreCase(Constants.BOTH))
 602                 validatedInstantiationType = Constants.MACRO;
 603             else if(instantiationType.equalsIgnoreCase(Constants.A_LA_CARTE))
 604                 validatedInstantiationType = Constants.A_LA_CARTE;
 605         }
 606         return validatedInstantiationType;
 607     }
 608
 609     private Map<String, ResourceGroup> extractVnfGroupsFromCsar(ISdcCsarHelper csarHelper, List<String> policiesTargets) {
 610         List<Group> resourceGroups = csarHelper.getGroupsOfTopologyTemplateByToscaGroupType(Constants.RESOURCE_GROUP_TYPE);
 611
 612         return resourceGroups.stream()
 613                 .filter(group -> group.getProperties().get(Constants.RESOURCE_GROUP_CONTAINED_TYPE).getValue().equals("VF"))
 614                 .collect(toMap(Group::getName, group -> parseResourceGroup(group, csarHelper, policiesTargets)));
 615     }
 616
 617     private ResourceGroup parseResourceGroup(Group group, ISdcCsarHelper csarHelper, List<String> policiesTargets) {
 618         return new ResourceGroup(
 619                 Constants.VNF_GROUP,
 620                 group.getMetadata().getValue(Constants.INVARIANT_UUID),
 621                 group.getMetadata().getValue(Constants.UUID),
 622                 group.getMetadata().getValue(Constants.VERSION),
 623                 group.getMetadata().getValue(Constants.NAME),
 624                 group.getMetadata().getValue(Constants.NAME),
 625                 getPropertiesOfResourceGroup(group.getProperties(), policiesTargets.contains(group.getName())),
 626                 csarHelper.getGroupMembersFromTopologyTemplate(group.getName()).stream()
 627                         .collect(toMap(NodeTemplate::getName, node -> getServiceProxyFromNodeTemplate(node, csarHelper, policiesTargets)))
 628         );
 629     }
 630
 631     private Map<String, Object> getPropertiesOfResourceGroup(Map<String, Property> properties, boolean hasPolicyTarget) {
 632         Map<String, Object> propertiesMap = properties.entrySet().stream()
 633                 .collect(toMap(Map.Entry::getKey, e -> e.getValue().getValue()));
 634         propertiesMap.put(Constants.ECOMP_GENERATED_NAMING_PROPERTY, String.valueOf(hasPolicyTarget));
 635
 636         return propertiesMap;
 637     }
 638
 639     public List<String> extractNamingPoliciesTargets(ISdcCsarHelper csarHelper) {
 640         List<Policy> policies = csarHelper.getPoliciesOfTopologyTemplateByToscaPolicyType(Constants.NAMING_POLICY_TYPE);
 641         return policies.stream()
 642                 .filter(policy -> policy.getProperties().get(Constants.TYPE) != null &&
 643                                 policy.getProperties().get(Constants.TYPE).getValue() != null &&
 644                         StringUtils.equalsIgnoreCase(policy.getProperties().get(Constants.TYPE).getValue().toString(), "naming"))
 645                 .flatMap(policy -> policy.getTargets().stream())
 646                 .collect(toList());
 647     }
 648 }