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

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