vid-app-common/src/main/java/org/onap/vid/services/AaiServiceImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * VID
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2018 Nokia. All rights reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.vid.services;
  23
  24 import com.fasterxml.jackson.databind.JsonNode;
  25 import com.fasterxml.jackson.databind.ObjectMapper;
  26 import io.joshworks.restclient.http.HttpResponse;
  27 import org.apache.http.HttpStatus;
  28 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
  29 import org.onap.vid.aai.*;
  30 import org.onap.vid.aai.model.*;
  31 import org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.AaiGetRelatedInstanceGroupsByVnfId;
  32 import org.onap.vid.aai.model.AaiGetOperationalEnvironments.OperationalEnvironmentList;
  33 import org.onap.vid.aai.model.AaiGetPnfs.Pnf;
  34 import org.onap.vid.aai.model.AaiGetServicesRequestModel.GetServicesAAIRespone;
  35 import org.onap.vid.aai.model.Properties;
  36 import org.onap.vid.aai.model.AaiGetTenatns.GetTenantsResponse;
  37 import org.onap.vid.asdc.beans.Service;
  38 import org.onap.vid.exceptions.GenericUncheckedException;
  39 import org.onap.vid.model.ServiceInstanceSearchResult;
  40 import org.onap.vid.model.SubscriberList;
  41 import org.onap.vid.model.aaiTree.AAITreeNode;
  42 import org.onap.vid.model.aaiTree.RelatedVnf;
  43 import org.onap.vid.roles.RoleValidator;
  44 import org.onap.vid.utils.Intersection;
  45 import org.onap.vid.utils.Tree;
  46 import org.springframework.beans.factory.annotation.Autowired;
  47
  48 import javax.ws.rs.core.Response;
  49 import java.io.UnsupportedEncodingException;
  50 import java.net.URLEncoder;
  51 import java.util.*;
  52 import java.util.stream.Collectors;
  53
  54 /**
  55  * Created by Oren on 7/4/17.
  56  */
  57 public class AaiServiceImpl implements AaiService {
  58     private static final String SERVICE_INSTANCE_ID = "service-instance.service-instance-id";
  59     private static final String SERVICE_TYPE = "service-subscription.service-type";
  60     private static final String CUSTOMER_ID = "customer.global-customer-id";
  61     private static final String SERVICE_INSTANCE_NAME = "service-instance.service-instance-name";
  62     private static final String TENANT_NODE_TYPE = "tenant";
  63     private static final String CLOUD_REGION_NODE_TYPE = "cloud-region";
  64     private int indexOfSubscriberName = 6;
  65
  66     @Autowired
  67     private AaiClientInterface aaiClient;
  68
  69     @Autowired
  70     private AaiOverTLSClientInterface aaiOverTLSClient;
  71
  72     @Autowired
  73     private AaiResponseTranslator aaiResponseTranslator;
  74
  75     @Autowired
  76     private AAITreeNodeBuilder aaiTreeNode;
  77
  78     @Autowired
  79     private AAIServiceTree aaiServiceTree;
  80
  81     private static final EELFLoggerDelegate LOGGER = EELFLoggerDelegate.getLogger(AaiServiceImpl.class);
  82
  83     private List<Service> convertModelToService(Model model) {
  84         List<Service> services = new ArrayList<>();
  85         String category = "";
  86
  87         if(validateModel(model)){
  88             if(model.getModelType() != null) {
  89                 category = model.getModelType();
  90             }
  91
  92             for (ModelVer modelVer: model.getModelVers().getModelVer()) {
  93                 Service service = new Service(
  94                         modelVer.getModelVersionId(),
  95                         model.getModelInvariantId(),
  96                         category, modelVer.getModelVersion(), modelVer.getModelName(),
  97                         modelVer.getDistributionStatus(),
  98                         null, null, null, null
  99                 );
 100
 101                 services.add(service);
 102             }
 103         } else {
 104             return Collections.emptyList();
 105         }
 106
 107         return services;
 108     }
 109
 110     private boolean validateModel(Model model){
 111         if (model == null) {
 112             return false;
 113         } else {
 114             return model.getModelVers() != null && model.getModelVers().getModelVer() != null && model.getModelVers().getModelVer().get(0).getModelVersionId() != null;
 115         }
 116     }
 117
 118     private List<ServiceInstanceSearchResult> getServicesByOwningEntityId(List<String> owningEntities, RoleValidator roleValidator) {
 119         AaiResponse<OwningEntityResponse> owningEntityResponse = aaiClient.getServicesByOwningEntityId(owningEntities);
 120         List<ServiceInstanceSearchResult> serviceInstanceSearchResultList = new ArrayList<>();
 121         if (owningEntityResponse.getT() != null) {
 122             for (OwningEntity owningEntity : owningEntityResponse.getT().getOwningEntity()) {
 123                 if (owningEntity.getRelationshipList() != null) {
 124                     serviceInstanceSearchResultList = convertRelationshipToSearchResult(owningEntity, serviceInstanceSearchResultList, roleValidator);
 125                 }
 126             }
 127         }
 128         return serviceInstanceSearchResultList;
 129     }
 130
 131     private List<ServiceInstanceSearchResult> getServicesByProjectNames(List<String> projectNames, RoleValidator roleValidator) {
 132         AaiResponse<ProjectResponse> projectByIdResponse = aaiClient.getServicesByProjectNames(projectNames);
 133         List<ServiceInstanceSearchResult> serviceInstanceSearchResultList = new ArrayList<>();
 134         if (projectByIdResponse.getT() != null) {
 135             for (Project project : projectByIdResponse.getT().getProject()) {
 136                 if (project.getRelationshipList() != null) {
 137                     serviceInstanceSearchResultList = convertRelationshipToSearchResult(project, serviceInstanceSearchResultList, roleValidator);
 138                 }
 139             }
 140         }
 141         return serviceInstanceSearchResultList;
 142     }
 143
 144     private List<ServiceInstanceSearchResult> convertRelationshipToSearchResult(AaiRelationResponse owningEntityResponse, List<ServiceInstanceSearchResult> serviceInstanceSearchResultList, RoleValidator roleValidator) {
 145         if (owningEntityResponse.getRelationshipList().getRelationship() != null) {
 146             List<Relationship> relationshipList = owningEntityResponse.getRelationshipList().getRelationship();
 147             for (Relationship relationship : relationshipList) {
 148                 ServiceInstanceSearchResult serviceInstanceSearchResult = new ServiceInstanceSearchResult();
 149                 extractRelationshipData(relationship, serviceInstanceSearchResult, roleValidator);
 150                 extractRelatedToProperty(relationship, serviceInstanceSearchResult);
 151                 serviceInstanceSearchResultList.add(serviceInstanceSearchResult);
 152             }
 153         }
 154         return serviceInstanceSearchResultList;
 155     }
 156
 157     private void extractRelationshipData(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult, RoleValidator roleValidator) {
 158         List<RelationshipData> relationshipDataList = relationship.getRelationDataList();
 159         if (relationshipDataList != null) {
 160             setSubscriberName(relationship, serviceInstanceSearchResult);
 161             for (RelationshipData relationshipData : relationshipDataList) {
 162                 String key = relationshipData.getRelationshipKey();
 163                 if (key.equals(SERVICE_INSTANCE_ID)) {
 164                     serviceInstanceSearchResult.setServiceInstanceId(relationshipData.getRelationshipValue());
 165                 } else if (key.equals(SERVICE_TYPE)) {
 166                     serviceInstanceSearchResult.setServiceType(relationshipData.getRelationshipValue());
 167                 } else if (key.equals(CUSTOMER_ID)) {
 168                     serviceInstanceSearchResult.setGlobalCustomerId(relationshipData.getRelationshipValue());
 169                 }
 170             }
 171
 172             boolean isPermitted = roleValidator.isServicePermitted(serviceInstanceSearchResult.getSubscriberName(), serviceInstanceSearchResult.getServiceType());
 173             serviceInstanceSearchResult.setIsPermitted(isPermitted);
 174         }
 175     }
 176
 177     private void setSubscriberName(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult) {
 178         String relatedLink = relationship.getRelatedLink();
 179         String[] subsciber = relatedLink.split("/");
 180         serviceInstanceSearchResult.setSubscriberName(subsciber[indexOfSubscriberName]);
 181     }
 182
 183     private void extractRelatedToProperty(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult) {
 184         List<RelatedToProperty> relatedToPropertyList = relationship.getRelatedToPropertyList();
 185         if (relatedToPropertyList != null) {
 186             for (RelatedToProperty relatedToProperty : relatedToPropertyList) {
 187                 if (relatedToProperty.getPropertyKey().equals(SERVICE_INSTANCE_NAME)) {
 188                     serviceInstanceSearchResult.setServiceInstanceName(relatedToProperty.getPropertyValue());
 189                 }
 190             }
 191         }
 192     }
 193
 194     @Override
 195     public SubscriberFilteredResults getFullSubscriberList(RoleValidator roleValidator) {
 196         HttpResponse<SubscriberList> allSubscribers = aaiOverTLSClient.getAllSubscribers();
 197         return new SubscriberFilteredResults(
 198             roleValidator,
 199             allSubscribers.getBody(),
 200             allSubscribers.getStatusText(),
 201             allSubscribers.getStatus()
 202         );
 203     }
 204
 205     @Override
 206     public AaiResponse<OperationalEnvironmentList> getOperationalEnvironments(String operationalEnvironmentType, String operationalEnvironmentStatus) {
 207         return aaiClient.getOperationalEnvironments(operationalEnvironmentType, operationalEnvironmentStatus);
 208     }
 209
 210     @Override
 211     public HttpResponse<SubscriberList> getFullSubscriberList() {
 212         return aaiOverTLSClient.getAllSubscribers();
 213     }
 214
 215     @Override
 216     public AaiResponse getSubscriberData(String subscriberId, RoleValidator roleValidator) {
 217         AaiResponse<Services> subscriberResponse = aaiClient.getSubscriberData(subscriberId);
 218         String subscriberGlobalId = subscriberResponse.getT().globalCustomerId;
 219         for (ServiceSubscription serviceSubscription : subscriberResponse.getT().serviceSubscriptions.serviceSubscription) {
 220             String serviceType = serviceSubscription.serviceType;
 221             serviceSubscription.isPermitted = roleValidator.isServicePermitted(subscriberGlobalId, serviceType);
 222         }
 223         return subscriberResponse;
 224
 225     }
 226
 227     @Override
 228     public AaiResponse getServiceInstanceSearchResults(String subscriberId, String instanceIdentifier, RoleValidator roleValidator, List<String> owningEntities, List<String> projects) {
 229         List<List<ServiceInstanceSearchResult>> resultList = new ArrayList<>();
 230         ServiceInstancesSearchResults serviceInstancesSearchResults = new ServiceInstancesSearchResults();
 231
 232         if (subscriberId != null || instanceIdentifier != null) {
 233             resultList.add(getServicesBySubscriber(subscriberId, instanceIdentifier, roleValidator));
 234         }
 235         if (owningEntities != null) {
 236             resultList.add(getServicesByOwningEntityId(owningEntities, roleValidator));
 237         }
 238         if (projects != null) {
 239             resultList.add(getServicesByProjectNames(projects, roleValidator));
 240         }
 241         if (!resultList.isEmpty()) {
 242             serviceInstancesSearchResults.serviceInstances = Intersection.of(resultList);
 243         }
 244
 245         return new AaiResponse<>(serviceInstancesSearchResults, null, HttpStatus.SC_OK);
 246     }
 247
 248
 249     private List<ServiceInstanceSearchResult> getServicesBySubscriber(String subscriberId, String instanceIdentifier, RoleValidator roleValidator) {
 250         AaiResponse<Services> subscriberResponse = aaiClient.getSubscriberData(subscriberId);
 251         String subscriberGlobalId = subscriberResponse.getT().globalCustomerId;
 252         String subscriberName = subscriberResponse.getT().subscriberName;
 253         ServiceSubscriptions serviceSubscriptions = subscriberResponse.getT().serviceSubscriptions;
 254
 255         return getSearchResultsForSubscriptions(serviceSubscriptions, subscriberId, instanceIdentifier, roleValidator, subscriberGlobalId, subscriberName);
 256
 257     }
 258
 259
 260     private ArrayList<ServiceInstanceSearchResult> getSearchResultsForSubscriptions(ServiceSubscriptions serviceSubscriptions, String subscriberId, String instanceIdentifier, RoleValidator roleValidator, String subscriberGlobalId, String subscriberName) {
 261         ArrayList<ServiceInstanceSearchResult> results = new ArrayList<>();
 262
 263         if (serviceSubscriptions != null) {
 264             for (ServiceSubscription serviceSubscription : serviceSubscriptions.serviceSubscription) {
 265                 String serviceType = serviceSubscription.serviceType;
 266                 serviceSubscription.isPermitted = roleValidator.isServicePermitted(subscriberGlobalId, serviceType);
 267                 ArrayList<ServiceInstanceSearchResult> resultsForSubscription = getSearchResultsForSingleSubscription(serviceSubscription, subscriberId, instanceIdentifier, subscriberName, serviceType);
 268                 results.addAll(resultsForSubscription);
 269             }
 270         }
 271
 272         return results;
 273     }
 274
 275     private ArrayList<ServiceInstanceSearchResult> getSearchResultsForSingleSubscription(ServiceSubscription serviceSubscription, String subscriberId, String instanceIdentifier, String subscriberName, String serviceType) {
 276         ArrayList<ServiceInstanceSearchResult> results = new ArrayList<>();
 277
 278         if (serviceSubscription.serviceInstances != null) {
 279             for (ServiceInstance serviceInstance : serviceSubscription.serviceInstances.serviceInstance) {
 280                 ServiceInstanceSearchResult serviceInstanceSearchResult =
 281                         new ServiceInstanceSearchResult(serviceInstance.serviceInstanceId, subscriberId, serviceType, serviceInstance.serviceInstanceName,
 282                                 subscriberName, serviceInstance.modelInvariantId, serviceInstance.modelVersionId, serviceSubscription.isPermitted);
 283
 284                 if ((instanceIdentifier == null) || (serviceInstanceMatchesIdentifier(instanceIdentifier, serviceInstance))){
 285                     results.add(serviceInstanceSearchResult);
 286                 }
 287             }
 288         }
 289
 290         return results;
 291     }
 292
 293     private boolean serviceInstanceMatchesIdentifier(String instanceIdentifier, ServiceInstance serviceInstance) {
 294         return instanceIdentifier.equals(serviceInstance.serviceInstanceId) || instanceIdentifier.equals(serviceInstance.serviceInstanceName);
 295     }
 296
 297     @Override
 298     public Response getVersionByInvariantId(List<String> modelInvariantId) {
 299         try {
 300             return aaiClient.getVersionByInvariantId(modelInvariantId);
 301         } catch (Exception e) {
 302             LOGGER.error(EELFLoggerDelegate.errorLogger, "Failed to getVersionByInvariantId from A&AI", e);
 303         }
 304         return null;
 305     }
 306
 307     @Override
 308     public AaiResponse<Pnf> getSpecificPnf(String pnfId) {
 309         return aaiClient.getSpecificPnf(pnfId);
 310     }
 311
 312     @Override
 313     public AaiResponse getPNFData(String globalCustomerId, String serviceType, String modelVersionId, String modelInvariantId, String cloudRegion, String equipVendor, String equipModel) {
 314         return aaiClient.getPNFData(globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion, equipVendor, equipModel);
 315     }
 316
 317
 318
 319     @Override
 320     public AaiResponse getServices(RoleValidator roleValidator) {
 321         AaiResponse<GetServicesAAIRespone> subscriberResponse = aaiClient.getServices();
 322         if (subscriberResponse.getT() != null) {
 323             for (org.onap.vid.aai.model.AaiGetServicesRequestModel.Service service : subscriberResponse.getT().service) {
 324                 service.isPermitted = true;
 325             }
 326         }
 327         return subscriberResponse;
 328     }
 329
 330     @Override
 331     public AaiResponse<GetTenantsResponse[]> getTenants(String globalCustomerId, String serviceType, RoleValidator roleValidator) {
 332         AaiResponse<GetTenantsResponse[]> aaiGetTenantsResponse = aaiClient.getTenants(globalCustomerId, serviceType);
 333         GetTenantsResponse[] tenants = aaiGetTenantsResponse.getT();
 334         if (tenants != null) {
 335             for (int i = 0; i < tenants.length; i++) {
 336                 tenants[i].isPermitted = roleValidator.isTenantPermitted(globalCustomerId, serviceType, tenants[i].tenantName);
 337             }
 338         }
 339         return aaiGetTenantsResponse;
 340
 341
 342     }
 343
 344     @Override
 345     public AaiResponse getVNFData(String globalSubscriberId, String serviceType, String serviceInstanceId) {
 346         return aaiClient.getVNFData(globalSubscriberId, serviceType, serviceInstanceId);
 347     }
 348
 349     @Override
 350     public AaiResponse<AaiGetVnfResponse> getVNFData(String globalSubscriberId, String serviceType) {
 351         AaiResponse response = aaiClient.getVNFData(globalSubscriberId, serviceType);
 352         return filterChangeManagementVNFCandidatesResponse(response);
 353     }
 354
 355     private AaiResponse<AaiGetVnfResponse> filterChangeManagementVNFCandidatesResponse(AaiResponse<AaiGetVnfResponse> response) {
 356
 357
 358         if (response != null && response.getT() != null) {
 359             response.getT().results =
 360                     response.getT().results.stream()
 361                             .filter(result -> (
 362                                     result.nodeType.equalsIgnoreCase("generic-vnf") ||
 363                                             result.nodeType.equalsIgnoreCase("service-instance")))
 364                             .collect(Collectors.toList());
 365
 366             return response;
 367         }
 368
 369         return new AaiResponse();
 370     }
 371
 372     @Override
 373     public AaiResponse getAaiZones() {
 374         return aaiClient.getAllAicZones();
 375     }
 376
 377     @Override
 378     public AaiResponse getAicZoneForPnf(String globalCustomerId, String serviceType, String serviceId) {
 379         String aicZone = "";
 380
 381         AaiResponse<ServiceRelationships> serviceInstanceResp = aaiClient.getServiceInstance(globalCustomerId, serviceType, serviceId);
 382         if (serviceInstanceResp.getT() != null) {
 383             List<String> aicZoneList = getRelationshipDataByType(serviceInstanceResp.getT().getRelationshipList(), "zone", "zone.zone-id");
 384             if (!aicZoneList.isEmpty()) {
 385                 aicZone = aicZoneList.get(0);
 386             } else {
 387                 LOGGER.warn("aic zone not found for service instance " + serviceId);
 388             }
 389         } else {
 390             if (serviceInstanceResp.getErrorMessage() != null) {
 391                 LOGGER.error("get service instance {} return error {}", serviceId, serviceInstanceResp.getErrorMessage());
 392                 return new AaiResponse(aicZone , serviceInstanceResp.getErrorMessage() ,serviceInstanceResp.getHttpCode());
 393             } else {
 394                 LOGGER.warn("get service instance {} return empty body", serviceId);
 395                 return new AaiResponse(aicZone , "get service instance " + serviceId + " return empty body" ,serviceInstanceResp.getHttpCode());
 396             }
 397         }
 398
 399         return new AaiResponse(aicZone , null ,HttpStatus.SC_OK);
 400     }
 401
 402     @Override
 403     public AaiResponse getNodeTemplateInstances(String globalCustomerId, String serviceType, String modelVersionId, String modelInvariantId, String cloudRegion) {
 404         return aaiClient.getNodeTemplateInstances(globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion);
 405     }
 406
 407     @Override
 408     public AaiResponse getNetworkCollectionDetails(String serviceInstanceId){
 409         return aaiClient.getNetworkCollectionDetails(serviceInstanceId);
 410     }
 411
 412     @Override
 413     public AaiResponse<AaiGetInstanceGroupsByCloudRegion> getInstanceGroupsByCloudRegion(String cloudOwner, String cloudRegionId, String networkFunction){
 414         return aaiClient.getInstanceGroupsByCloudRegion(cloudOwner, cloudRegionId, networkFunction);
 415     }
 416
 417     @Override
 418     public Collection<Service> getServicesByDistributionStatus() {
 419         AaiResponse<GetServiceModelsByDistributionStatusResponse> serviceModelsByDistributionStatusResponse = aaiClient.getServiceModelsByDistributionStatus();
 420         Collection<Service> services = new ArrayList<>();
 421         if (serviceModelsByDistributionStatusResponse.getT() != null) {
 422             List<Result> results = serviceModelsByDistributionStatusResponse.getT().getResults();
 423             for (Result result : results) {
 424                 if(result.getModel() != null) {
 425                     List<Service> service = convertModelToService(result.getModel());
 426                     services.addAll(service);
 427                 }
 428             }
 429         }
 430         return services;
 431     }
 432
 433     @Override
 434     public List<String> getServiceInstanceAssociatedPnfs(String globalCustomerId, String serviceType, String serviceInstanceId) {
 435         List<String> pnfs = new ArrayList<>();
 436
 437         AaiResponse<ServiceRelationships> serviceInstanceResp = aaiClient.getServiceInstance(globalCustomerId, serviceType, serviceInstanceId);
 438         if (serviceInstanceResp.getT() != null) {
 439
 440             addPnfsToListViaLogicalLinks(pnfs, serviceInstanceResp);
 441             addPnfsToListViaDirectRelations(pnfs, serviceInstanceResp);
 442
 443             if (pnfs.isEmpty()) {
 444                 LOGGER.warn("no pnf direct relation found for service id:" + serviceInstanceId+
 445                         " name: "+serviceInstanceResp.getT().getServiceInstanceName());
 446             }
 447         } else {
 448             if (serviceInstanceResp.getErrorMessage() != null) {
 449                 LOGGER.error("get service instance {} return error {}", serviceInstanceId, serviceInstanceResp.getErrorMessage());
 450             } else {
 451                 LOGGER.warn("get service instance {} return empty body", serviceInstanceId);
 452             }
 453         }
 454
 455         return pnfs.stream().distinct().collect(Collectors.toList());
 456     }
 457
 458     @Override
 459     public AaiResponseTranslator.PortMirroringConfigData getPortMirroringConfigData(String configurationId) {
 460         AaiResponse<JsonNode> aaiResponse = aaiClient.getCloudRegionAndSourceByPortMirroringConfigurationId(configurationId);
 461         return aaiResponseTranslator.extractPortMirroringConfigData(aaiResponse);
 462     }
 463
 464     @Override
 465     public AaiResponse getInstanceGroupsByVnfInstanceId(String vnfInstanceId){
 466         AaiResponse<AaiGetRelatedInstanceGroupsByVnfId> aaiResponse = aaiClient.getInstanceGroupsByVnfInstanceId(vnfInstanceId);
 467         if(aaiResponse.getHttpCode() == HttpStatus.SC_OK){
 468             return new AaiResponse(convertGetInstanceGroupsResponseToSimpleResponse(aaiResponse.getT()), aaiResponse.getErrorMessage(), aaiResponse.getHttpCode());
 469         }
 470         return aaiClient.getInstanceGroupsByVnfInstanceId(vnfInstanceId);
 471     }
 472
 473     @Override
 474     public GetTenantsResponse getHomingDataByVfModule(String vnfInstanceId, String vfModuleId) {
 475         return aaiClient.getHomingDataByVfModule(vnfInstanceId,vfModuleId);
 476     }
 477
 478     @Override
 479     public List<RelatedVnf> searchGroupMembers(String globalCustomerId, String serviceType, String invariantId, String groupType, String groupRole) {
 480         String getURL = "business/customers/customer/" +
 481                     globalCustomerId + "/service-subscriptions/service-subscription/" +
 482                     serviceType + "/service-instances?model-invariant-id=" + invariantId;
 483
 484         Tree<AAIServiceTree.AaiRelationship> pathsToSearch = new Tree<>(new AAIServiceTree.AaiRelationship(AAITreeNodeBuilder.SERVICE_INSTANCE));
 485         pathsToSearch.addPath(AAITreeNodeBuilder.toAaiRelationshipList(AAITreeNodeBuilder.GENERIC_VNF, AAITreeNodeBuilder.INSTANCE_GROUP));
 486
 487         //get all vnfs related to service-instances from the model-invariant-id
 488         List<AAITreeNode> aaiTree = aaiServiceTree.buildAAITree(getURL, pathsToSearch);
 489
 490         //filter by instance-group-role & instance-group-type properties (from getAdditionalProperties)
 491         //only vnfs has related instance-group with the same groupType & groupRole - are filtered out.
 492         List<AAITreeNode> filteredVnfs = filterByInstanceGroupRoleAndType(aaiTree, groupRole, groupType);
 493
 494         //convert vnfs to expected result
 495         return filteredVnfs.stream()
 496                 .map(RelatedVnf::from)
 497                 .map(this::enrichRelatedVnfWithCloudRegionAndTenant)
 498                 .collect(Collectors.toList());
 499     }
 500
 501     private List<AAITreeNode> filterByInstanceGroupRoleAndType(List<AAITreeNode> aaiTree, String groupRole, String groupType) {
 502
 503         return aaiTree.stream()
 504                 .map(AAITreeNode::getChildren)
 505                 .flatMap(Collection::stream)
 506                 .filter(vnf -> isInstanceGroupsNotMatchRoleAndType(vnf.getChildren(), groupRole, groupType))
 507                 .collect(Collectors.toList());
 508     }
 509
 510     public boolean isInstanceGroupsNotMatchRoleAndType(List<AAITreeNode> instanceGroups, String groupRole, String groupType) {
 511         return instanceGroups.stream()
 512                 .map(AAITreeNode::getAdditionalProperties)
 513                 .allMatch(props ->
 514                         (!(groupRole.equals(props.get("instance-group-role")) &&
 515                                 groupType.equals(props.get("instance-group-type"))))
 516                 );
 517     }
 518
 519     public RelatedVnf enrichRelatedVnfWithCloudRegionAndTenant(RelatedVnf vnf) {
 520         Map<String, Properties> cloudRegionAndTenant = aaiClient.getCloudRegionAndTenantByVnfId(vnf.getInstanceId());
 521
 522         if (cloudRegionAndTenant.containsKey(TENANT_NODE_TYPE)) {
 523             vnf.setTenantId(cloudRegionAndTenant.get(TENANT_NODE_TYPE).getTenantId());
 524             vnf.setTenantName(cloudRegionAndTenant.get(TENANT_NODE_TYPE).getTenantName());
 525         }
 526
 527         if (cloudRegionAndTenant.containsKey(CLOUD_REGION_NODE_TYPE)) {
 528             vnf.setLcpCloudRegionId(cloudRegionAndTenant.get(CLOUD_REGION_NODE_TYPE).getCloudRegionId());
 529         }
 530
 531         return vnf;
 532     }
 533     private List<InstanceGroupInfo> convertGetInstanceGroupsResponseToSimpleResponse(AaiGetRelatedInstanceGroupsByVnfId response) {
 534         List<InstanceGroupInfo> instanceGroupInfoList = new ArrayList<>();
 535         for(org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Relationship relationship: response.getRelationshipList().getRelationship()){
 536             getInstanceGroupInfoFromRelationship(relationship, instanceGroupInfoList);
 537         }
 538         return instanceGroupInfoList;
 539     }
 540
 541     private void getInstanceGroupInfoFromRelationship(org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Relationship relationship, List<InstanceGroupInfo> instanceGroupInfoList) {
 542         if(relationship.getRelatedTo().equals("instance-group")){
 543             for(org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.RelatedToProperty relatedToProperty: relationship.getRelatedToPropertyList()){
 544                 if(relatedToProperty.getPropertyKey().equals("instance-group.instance-group-name")){
 545                     instanceGroupInfoList.add(new InstanceGroupInfo(relatedToProperty.getPropertyValue()));
 546                 }
 547             }
 548         }
 549     }
 550
 551     @Override
 552     public  List<PortDetailsTranslator.PortDetails> getPortMirroringSourcePorts(String configurationId){
 553         return aaiClient.getPortMirroringSourcePorts(configurationId);
 554     }
 555
 556     private void addPnfsToListViaDirectRelations(List<String> pnfs, AaiResponse<ServiceRelationships> serviceInstanceResp) {
 557         pnfs.addAll(getRelationshipDataByType(serviceInstanceResp.getT().getRelationshipList(), "pnf", "pnf.pnf-name"));
 558     }
 559
 560     private void addPnfsToListViaLogicalLinks(List<String> pnfs, AaiResponse<ServiceRelationships> serviceInstanceResp) {
 561         List<String> logicalLinks = getRelationshipDataByType(serviceInstanceResp.getT().getRelationshipList(), "logical-link", "logical-link.link-name");
 562         for (String logicalLink : logicalLinks) {
 563             String link;
 564             try {
 565                 link = URLEncoder.encode(logicalLink, "UTF-8");
 566             } catch (UnsupportedEncodingException e) {
 567                 LOGGER.error("Failed to encode logical link: " + logicalLink, e);
 568                 continue;
 569             }
 570
 571             AaiResponse<LogicalLinkResponse> logicalLinkResp = aaiClient.getLogicalLink(link);
 572             if (logicalLinkResp.getT() != null) {
 573                 //lag-interface is the key for pnf - approved by Bracha
 574                 List<String> linkPnfs = getRelationshipDataByType(logicalLinkResp.getT().getRelationshipList(), "lag-interface", "pnf.pnf-name");
 575                 if (!linkPnfs.isEmpty()) {
 576                     pnfs.addAll(linkPnfs);
 577                 } else {
 578                     LOGGER.warn("no pnf found for logical link " + logicalLink);
 579                 }
 580             } else {
 581                 if (logicalLinkResp.getErrorMessage() != null) {
 582                     LOGGER.error("get logical link " + logicalLink + " return error", logicalLinkResp.getErrorMessage());
 583                 } else {
 584                     LOGGER.warn("get logical link " + logicalLink + " return empty body");
 585                 }
 586             }
 587         }
 588     }
 589
 590     private List<String> getRelationshipDataByType(RelationshipList relationshipList, String relationshipType, String relationshipDataKey) {
 591         List<String> relationshipValues = new ArrayList<>();
 592         for (Relationship relationship : relationshipList.getRelationship()) {
 593             if (relationship.getRelatedTo().equals(relationshipType)) {
 594                 relationshipValues.addAll( relationship.getRelationDataList().stream()
 595                         .filter(rel -> rel.getRelationshipKey().equals(relationshipDataKey))
 596                         .map(RelationshipData::getRelationshipValue)
 597                         .collect(Collectors.toList())
 598                 );
 599             }
 600         }
 601
 602
 603         return relationshipValues;
 604     }
 605
 606     public String getAAIServiceTree(String globalCustomerId, String serviceType, String serviceInstanceId) {
 607         ObjectMapper om = new ObjectMapper();
 608         String result;
 609         try {
 610             org.onap.vid.model.aaiTree.ServiceInstance tree = aaiServiceTree.getServiceInstanceTopology(globalCustomerId, serviceType, serviceInstanceId);
 611             result = om.writeValueAsString(tree);
 612         } catch (Exception e) {
 613             throw new GenericUncheckedException(e);
 614         }
 615         return result;
 616     }
 617 }