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