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

   1 package org.onap.vid.services;
   2
   3 import org.apache.http.HttpStatus;
   4 import org.codehaus.jackson.JsonNode;
   5 import org.onap.vid.aai.*;
   6 import org.onap.vid.aai.ServiceInstance;
   7 import org.onap.vid.aai.ServiceSubscription;
   8 import org.onap.vid.aai.Services;
   9 import org.onap.vid.aai.model.AaiGetAicZone.AicZones;
  10 import org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.AaiGetNetworkCollectionDetails;
  11 import org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.AaiGetRelatedInstanceGroupsByVnfId;
  12 import org.onap.vid.aai.model.AaiGetOperationalEnvironments.OperationalEnvironmentList;
  13 import org.onap.vid.aai.model.AaiGetPnfs.Pnf;
  14 import org.onap.vid.aai.model.AaiGetServicesRequestModel.GetServicesAAIRespone;
  15 import org.onap.vid.aai.model.AaiGetTenatns.GetTenantsResponse;
  16 import org.onap.vid.aai.model.*;
  17 import org.onap.vid.asdc.beans.Service;
  18 import org.onap.vid.model.ServiceInstanceSearchResult;
  19 import org.onap.vid.model.SubscriberList;
  20 import org.onap.vid.roles.RoleValidator;
  21 import org.onap.vid.utils.Intersection;
  22 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
  23 import org.springframework.beans.factory.annotation.Autowired;
  24
  25 import javax.ws.rs.core.Response;
  26 import java.io.UnsupportedEncodingException;
  27 import java.net.URLEncoder;
  28 import java.util.ArrayList;
  29 import java.util.Collection;
  30 import java.util.Collections;
  31 import java.util.List;
  32 import java.util.stream.Collectors;
  33
  34 /**
  35  * Created by Oren on 7/4/17.
  36  */
  37 public class AaiServiceImpl implements AaiService {
  38     private static final String SERVICE_INSTANCE_ID = "service-instance.service-instance-id";
  39     private static final String SERVICE_TYPE = "service-subscription.service-type";
  40     private static final String CUSTOMER_ID = "customer.global-customer-id";
  41     private static final String SERVICE_INSTANCE_NAME = "service-instance.service-instance-name";
  42     private int indexOfSubscriberName = 6;
  43
  44     @Autowired
  45     private AaiClientInterface aaiClient;
  46
  47     @Autowired
  48     private AaiResponseTranslator aaiResponseTranslator;
  49
  50     private static final EELFLoggerDelegate LOGGER = EELFLoggerDelegate.getLogger(AaiServiceImpl.class);
  51
  52     private List<Service> convertModelToService(Model model) {
  53         List<Service> services = new ArrayList<>();
  54         String category = "";
  55
  56         if(validateModel(model)){
  57             if(model.getModelType() != null) {
  58                 category = model.getModelType();
  59             }
  60
  61             for (ModelVer modelVer: model.getModelVers().getModelVer()) {
  62                 Service service = new Service(
  63                         modelVer.getModelVersionId(),
  64                         model.getModelInvariantId(),
  65                         category, modelVer.getModelVersion(), modelVer.getModelName(),
  66                         modelVer.getDistributionStatus(),
  67                         null, null, null, null
  68                 );
  69
  70                 services.add(service);
  71             }
  72         } else {
  73             return Collections.emptyList();
  74         }
  75
  76         return services;
  77     }
  78
  79     private boolean validateModel(Model model){
  80         if (model == null) {
  81             return false;
  82         } else {
  83             return model.getModelVers() != null && model.getModelVers().getModelVer() != null && model.getModelVers().getModelVer().get(0).getModelVersionId() != null;
  84         }
  85     }
  86
  87     private List<ServiceInstanceSearchResult> getServicesByOwningEntityId(List<String> owningEntities, RoleValidator roleValidator) {
  88         AaiResponse<OwningEntityResponse> owningEntityResponse = aaiClient.getServicesByOwningEntityId(owningEntities);
  89         List<ServiceInstanceSearchResult> serviceInstanceSearchResultList = new ArrayList<>();
  90         if (owningEntityResponse.getT() != null) {
  91             for (OwningEntity owningEntity : owningEntityResponse.getT().getOwningEntity()) {
  92                 if (owningEntity.getRelationshipList() != null) {
  93                     serviceInstanceSearchResultList = convertRelationshipToSearchResult(owningEntity, serviceInstanceSearchResultList, roleValidator);
  94                 }
  95             }
  96         }
  97         return serviceInstanceSearchResultList;
  98     }
  99
 100     private List<ServiceInstanceSearchResult> getServicesByProjectNames(List<String> projectNames, RoleValidator roleValidator) {
 101         AaiResponse<ProjectResponse> projectByIdResponse = aaiClient.getServicesByProjectNames(projectNames);
 102         List<ServiceInstanceSearchResult> serviceInstanceSearchResultList = new ArrayList<>();
 103         if (projectByIdResponse.getT() != null) {
 104             for (Project project : projectByIdResponse.getT().getProject()) {
 105                 if (project.getRelationshipList() != null) {
 106                     serviceInstanceSearchResultList = convertRelationshipToSearchResult(project, serviceInstanceSearchResultList, roleValidator);
 107                 }
 108             }
 109         }
 110         return serviceInstanceSearchResultList;
 111     }
 112
 113     private List<ServiceInstanceSearchResult> convertRelationshipToSearchResult(AaiRelationResponse owningEntityResponse, List<ServiceInstanceSearchResult> serviceInstanceSearchResultList, RoleValidator roleValidator) {
 114         if (owningEntityResponse.getRelationshipList().getRelationship() != null) {
 115             List<Relationship> relationshipList = owningEntityResponse.getRelationshipList().getRelationship();
 116             for (Relationship relationship : relationshipList) {
 117                 ServiceInstanceSearchResult serviceInstanceSearchResult = new ServiceInstanceSearchResult();
 118                 extractRelationshipData(relationship, serviceInstanceSearchResult, roleValidator);
 119                 extractRelatedToProperty(relationship, serviceInstanceSearchResult);
 120                 serviceInstanceSearchResultList.add(serviceInstanceSearchResult);
 121             }
 122         }
 123         return serviceInstanceSearchResultList;
 124     }
 125
 126     private void extractRelationshipData(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult, RoleValidator roleValidator) {
 127         List<RelationshipData> relationshipDataList = relationship.getRelationDataList();
 128         if (relationshipDataList != null) {
 129             setSubscriberName(relationship, serviceInstanceSearchResult);
 130             for (RelationshipData relationshipData : relationshipDataList) {
 131                 String key = relationshipData.getRelationshipKey();
 132                 if (key.equals(SERVICE_INSTANCE_ID)) {
 133                     serviceInstanceSearchResult.setServiceInstanceId(relationshipData.getRelationshipValue());
 134                 } else if (key.equals(SERVICE_TYPE)) {
 135                     serviceInstanceSearchResult.setServiceType(relationshipData.getRelationshipValue());
 136                 } else if (key.equals(CUSTOMER_ID)) {
 137                     serviceInstanceSearchResult.setGlobalCustomerId(relationshipData.getRelationshipValue());
 138                 }
 139             }
 140
 141             boolean isPermitted = roleValidator.isServicePermitted(serviceInstanceSearchResult.getSubscriberName(), serviceInstanceSearchResult.getServiceType());
 142             serviceInstanceSearchResult.setIsPermitted(isPermitted);
 143         }
 144     }
 145
 146     private void setSubscriberName(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult) {
 147         String relatedLink = relationship.getRelatedLink();
 148         String[] subsciber = relatedLink.split("/");
 149         serviceInstanceSearchResult.setSubscriberName(subsciber[indexOfSubscriberName]);
 150     }
 151
 152     private void extractRelatedToProperty(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult) {
 153         List<RelatedToProperty> relatedToPropertyList = relationship.getRelatedToPropertyList();
 154         if (relatedToPropertyList != null) {
 155             for (RelatedToProperty relatedToProperty : relatedToPropertyList) {
 156                 if (relatedToProperty.getPropertyKey().equals(SERVICE_INSTANCE_NAME)) {
 157                     serviceInstanceSearchResult.setServiceInstanceName(relatedToProperty.getPropertyValue());
 158                 }
 159             }
 160         }
 161     }
 162
 163     @Override
 164     public SubscriberFilteredResults getFullSubscriberList(RoleValidator roleValidator) {
 165         AaiResponse<SubscriberList> subscriberResponse = aaiClient.getAllSubscribers();
 166
 167         return new SubscriberFilteredResults(roleValidator, subscriberResponse.getT(),
 168                 subscriberResponse.getErrorMessage(),
 169                 subscriberResponse.getHttpCode());
 170     }
 171
 172     @Override
 173     public AaiResponse<OperationalEnvironmentList> getOperationalEnvironments(String operationalEnvironmentType, String operationalEnvironmentStatus) {
 174         return aaiClient.getOperationalEnvironments(operationalEnvironmentType, operationalEnvironmentStatus);
 175     }
 176
 177     @Override
 178     public AaiResponse<SubscriberList> getFullSubscriberList() {
 179         return aaiClient.getAllSubscribers();
 180     }
 181
 182     @Override
 183     public AaiResponse getSubscriberData(String subscriberId, RoleValidator roleValidator) {
 184         AaiResponse<Services> subscriberResponse = aaiClient.getSubscriberData(subscriberId);
 185         String subscriberGlobalId = subscriberResponse.getT().globalCustomerId;
 186         for (ServiceSubscription serviceSubscription : subscriberResponse.getT().serviceSubscriptions.serviceSubscription) {
 187             String serviceType = serviceSubscription.serviceType;
 188             serviceSubscription.isPermitted = roleValidator.isServicePermitted(subscriberGlobalId, serviceType);
 189         }
 190         return subscriberResponse;
 191
 192     }
 193
 194     @Override
 195     public AaiResponse getServiceInstanceSearchResults(String subscriberId, String instanceIdentifier, RoleValidator roleValidator, List<String> owningEntities, List<String> projects) {
 196         List<List<ServiceInstanceSearchResult>> resultList = new ArrayList<>();
 197         ServiceInstancesSearchResults serviceInstancesSearchResults = new ServiceInstancesSearchResults();
 198
 199         if (subscriberId != null || instanceIdentifier != null) {
 200             resultList.add(getServicesBySubscriber(subscriberId, instanceIdentifier, roleValidator));
 201         }
 202         if (owningEntities != null) {
 203             resultList.add(getServicesByOwningEntityId(owningEntities, roleValidator));
 204         }
 205         if (projects != null) {
 206             resultList.add(getServicesByProjectNames(projects, roleValidator));
 207         }
 208         if (!resultList.isEmpty()) {
 209             Intersection<ServiceInstanceSearchResult> intersection = new Intersection<>();
 210             serviceInstancesSearchResults.serviceInstances = intersection.intersectMultipileArray(resultList);
 211         }
 212
 213         return new AaiResponse<>(serviceInstancesSearchResults, null, HttpStatus.SC_OK);
 214     }
 215
 216
 217     private List<ServiceInstanceSearchResult> getServicesBySubscriber(String subscriberId, String instanceIdentifier, RoleValidator roleValidator) {
 218         AaiResponse<Services> subscriberResponse = aaiClient.getSubscriberData(subscriberId);
 219         String subscriberGlobalId = subscriberResponse.getT().globalCustomerId;
 220         String subscriberName = subscriberResponse.getT().subscriberName;
 221         ServiceSubscriptions serviceSubscriptions = subscriberResponse.getT().serviceSubscriptions;
 222
 223         return getSearchResultsForSubscriptions(serviceSubscriptions, subscriberId, instanceIdentifier, roleValidator, subscriberGlobalId, subscriberName);
 224
 225     }
 226
 227
 228     private ArrayList<ServiceInstanceSearchResult> getSearchResultsForSubscriptions(ServiceSubscriptions serviceSubscriptions, String subscriberId, String instanceIdentifier, RoleValidator roleValidator, String subscriberGlobalId, String subscriberName) {
 229         ArrayList<ServiceInstanceSearchResult> results = new ArrayList<>();
 230
 231         if (serviceSubscriptions != null) {
 232             for (ServiceSubscription serviceSubscription : serviceSubscriptions.serviceSubscription) {
 233                 String serviceType = serviceSubscription.serviceType;
 234                 serviceSubscription.isPermitted = roleValidator.isServicePermitted(subscriberGlobalId, serviceType);
 235                 ArrayList<ServiceInstanceSearchResult> resultsForSubscription = getSearchResultsForSingleSubscription(serviceSubscription, subscriberId, instanceIdentifier, subscriberName, serviceType);
 236                 results.addAll(resultsForSubscription);
 237             }
 238         }
 239
 240         return results;
 241     }
 242
 243     private ArrayList<ServiceInstanceSearchResult> getSearchResultsForSingleSubscription(ServiceSubscription serviceSubscription, String subscriberId, String instanceIdentifier, String subscriberName, String serviceType) {
 244         ArrayList<ServiceInstanceSearchResult> results = new ArrayList<>();
 245
 246         if (serviceSubscription.serviceInstances != null) {
 247             for (ServiceInstance serviceInstance : serviceSubscription.serviceInstances.serviceInstance) {
 248                 ServiceInstanceSearchResult serviceInstanceSearchResult =
 249                         new ServiceInstanceSearchResult(serviceInstance.serviceInstanceId, subscriberId, serviceType, serviceInstance.serviceInstanceName,
 250                                 subscriberName, serviceInstance.modelInvariantId, serviceInstance.modelVersionId, serviceSubscription.isPermitted);
 251
 252                 if (instanceIdentifier == null) {
 253                     results.add(serviceInstanceSearchResult);
 254                 } else if (serviceInstanceMatchesIdentifier(instanceIdentifier, serviceInstance)) {
 255                     results.add(serviceInstanceSearchResult);
 256                 }
 257             }
 258         }
 259
 260         return results;
 261     }
 262
 263     private boolean serviceInstanceMatchesIdentifier(String instanceIdentifier, ServiceInstance serviceInstance) {
 264         return instanceIdentifier.equals(serviceInstance.serviceInstanceId) || instanceIdentifier.equals(serviceInstance.serviceInstanceName);
 265     }
 266
 267     @Override
 268     public Response getVersionByInvariantId(List<String> modelInvariantId) {
 269         try {
 270             return aaiClient.getVersionByInvariantId(modelInvariantId);
 271         } catch (Exception e) {
 272             LOGGER.error(EELFLoggerDelegate.errorLogger, "Failed to getVersionByInvariantId from A&AI", e);
 273         }
 274         return null;
 275     }
 276
 277     @Override
 278     public AaiResponse<Pnf> getSpecificPnf(String pnfId) {
 279         return aaiClient.getSpecificPnf(pnfId);
 280     }
 281
 282     @Override
 283     public AaiResponse getPNFData(String globalCustomerId, String serviceType, String modelVersionId, String modelInvariantId, String cloudRegion, String equipVendor, String equipModel) {
 284         return aaiClient.getPNFData(globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion, equipVendor, equipModel);
 285     }
 286
 287
 288
 289     @Override
 290     public AaiResponse getServices(RoleValidator roleValidator) {
 291         AaiResponse<GetServicesAAIRespone> subscriberResponse = aaiClient.getServices();
 292         if (subscriberResponse.getT() != null) {
 293             for (org.onap.vid.aai.model.AaiGetServicesRequestModel.Service service : subscriberResponse.getT().service) {
 294                 service.isPermitted = true;
 295             }
 296         }
 297         return subscriberResponse;
 298     }
 299
 300     @Override
 301     public AaiResponse<GetTenantsResponse[]> getTenants(String globalCustomerId, String serviceType, RoleValidator roleValidator) {
 302         AaiResponse<GetTenantsResponse[]> aaiGetTenantsResponse = aaiClient.getTenants(globalCustomerId, serviceType);
 303         GetTenantsResponse[] tenants = aaiGetTenantsResponse.getT();
 304         if (tenants != null) {
 305             for (int i = 0; i < tenants.length; i++) {
 306                 tenants[i].isPermitted = roleValidator.isTenantPermitted(globalCustomerId, serviceType, tenants[i].tenantName);
 307             }
 308         }
 309         return aaiGetTenantsResponse;
 310
 311
 312     }
 313
 314     @Override
 315     public AaiResponse getVNFData(String globalSubscriberId, String serviceType, String serviceInstanceId) {
 316         return aaiClient.getVNFData(globalSubscriberId, serviceType, serviceInstanceId);
 317     }
 318
 319     @Override
 320     public Response getVNFData(String globalSubscriberId, String serviceType) {
 321         return aaiClient.getVNFData(globalSubscriberId, serviceType);
 322     }
 323
 324     @Override
 325     public AaiResponse getAaiZones() {
 326         return (AaiResponse<AicZones>) aaiClient.getAllAicZones();
 327     }
 328
 329     @Override
 330     public AaiResponse getAicZoneForPnf(String globalCustomerId, String serviceType, String serviceId) {
 331         String aicZone = "";
 332
 333         AaiResponse<ServiceRelationships> serviceInstanceResp = aaiClient.getServiceInstance(globalCustomerId, serviceType, serviceId);
 334         if (serviceInstanceResp.getT() != null) {
 335             List<String> aicZoneList = getRelationshipDataByType(serviceInstanceResp.getT().getRelationshipList(), "zone", "zone.zone-id");
 336             if (!aicZoneList.isEmpty()) {
 337                 aicZone = aicZoneList.get(0);
 338             } else {
 339                 LOGGER.warn("aic zone not found for service instance " + serviceId);
 340             }
 341         } else {
 342             if (serviceInstanceResp.getErrorMessage() != null) {
 343                 LOGGER.error("get service instance {} return error {}", serviceId, serviceInstanceResp.getErrorMessage());
 344                 return new AaiResponse(aicZone , serviceInstanceResp.getErrorMessage() ,serviceInstanceResp.getHttpCode());
 345             } else {
 346                 LOGGER.warn("get service instance {} return empty body", serviceId);
 347                 return new AaiResponse(aicZone , "get service instance " + serviceId + " return empty body" ,serviceInstanceResp.getHttpCode());
 348             }
 349         }
 350
 351         return new AaiResponse(aicZone , null ,HttpStatus.SC_OK);
 352     }
 353
 354     @Override
 355     public AaiResponse getNodeTemplateInstances(String globalCustomerId, String serviceType, String modelVersionId, String modelInvariantId, String cloudRegion) {
 356         return aaiClient.getNodeTemplateInstances(globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion);
 357     }
 358
 359     @Override
 360     public AaiResponse getNetworkCollectionDetails(String serviceInstanceId){
 361         AaiResponse<AaiGetNetworkCollectionDetails> getNetworkCollectionDetailsAaiResponse = aaiClient.getNetworkCollectionDetails(serviceInstanceId);
 362         return getNetworkCollectionDetailsAaiResponse;
 363     }
 364
 365     @Override
 366     public AaiResponse<AaiGetInstanceGroupsByCloudRegion> getInstanceGroupsByCloudRegion(String cloudOwner, String cloudRegionId, String networkFunction){
 367         AaiResponse<AaiGetInstanceGroupsByCloudRegion> getInstanceGroupsByCloudRegionResponse = aaiClient.getInstanceGroupsByCloudRegion(cloudOwner, cloudRegionId, networkFunction);
 368         return getInstanceGroupsByCloudRegionResponse;
 369     }
 370
 371     @Override
 372     public Collection<Service> getServicesByDistributionStatus() {
 373         AaiResponse<GetServiceModelsByDistributionStatusResponse> serviceModelsByDistributionStatusResponse = aaiClient.getServiceModelsByDistributionStatus();
 374         Collection<Service> services = new ArrayList<>();
 375         if (serviceModelsByDistributionStatusResponse.getT() != null) {
 376             List<Result> results = serviceModelsByDistributionStatusResponse.getT().getResults();
 377             for (Result result : results) {
 378                 if(result.getModel() != null) {
 379                     List<Service> service = convertModelToService(result.getModel());
 380                     services.addAll(service);
 381                 }
 382             }
 383         }
 384         return services;
 385     }
 386
 387     @Override
 388     public List<String> getServiceInstanceAssociatedPnfs(String globalCustomerId, String serviceType, String serviceInstanceId) {
 389         List<String> pnfs = new ArrayList<>();
 390
 391         AaiResponse<ServiceRelationships> serviceInstanceResp = aaiClient.getServiceInstance(globalCustomerId, serviceType, serviceInstanceId);
 392         if (serviceInstanceResp.getT() != null) {
 393
 394             addPnfsToListViaLogicalLinks(pnfs, serviceInstanceResp);
 395             addPnfsToListViaDirectRelations(pnfs, serviceInstanceResp);
 396
 397             if (pnfs.isEmpty()) {
 398                 LOGGER.warn("no pnf direct relation found for service id:" + serviceInstanceId+
 399                         " name: "+serviceInstanceResp.getT().getServiceInstanceName());
 400             }
 401         } else {
 402             if (serviceInstanceResp.getErrorMessage() != null) {
 403                 LOGGER.error("get service instance {} return error {}", serviceInstanceId, serviceInstanceResp.getErrorMessage());
 404             } else {
 405                 LOGGER.warn("get service instance {} return empty body", serviceInstanceId);
 406             }
 407         }
 408
 409         return pnfs.stream().distinct().collect(Collectors.toList());
 410     }
 411
 412     @Override
 413     public AaiResponseTranslator.PortMirroringConfigData getPortMirroringConfigData(String configurationId) {
 414         AaiResponse<JsonNode> aaiResponse = aaiClient.getCloudRegionAndSourceByPortMirroringConfigurationId(configurationId);
 415         return aaiResponseTranslator.extractPortMirroringConfigData(aaiResponse);
 416     }
 417
 418     @Override
 419     public AaiResponse getInstanceGroupsByVnfInstanceId(String vnfInstanceId){
 420         AaiResponse<AaiGetRelatedInstanceGroupsByVnfId> aaiResponse = aaiClient.getInstanceGroupsByVnfInstanceId(vnfInstanceId);
 421         if(aaiResponse.getHttpCode() == HttpStatus.SC_OK){
 422             return new AaiResponse(convertGetInstanceGroupsResponseToSimpleResponse(aaiResponse.getT()), aaiResponse.getErrorMessage(), aaiResponse.getHttpCode());
 423         }
 424         return aaiClient.getInstanceGroupsByVnfInstanceId(vnfInstanceId);
 425     }
 426
 427     private List<InstanceGroupInfo> convertGetInstanceGroupsResponseToSimpleResponse(AaiGetRelatedInstanceGroupsByVnfId response) {
 428         List<InstanceGroupInfo> instanceGroupInfoList = new ArrayList<>();
 429         for(org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Relationship relationship: response.getRelationshipList().getRelationship()){
 430             getInstanceGroupInfoFromRelationship(relationship, instanceGroupInfoList);
 431         }
 432         return instanceGroupInfoList;
 433     }
 434
 435     private void getInstanceGroupInfoFromRelationship(org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Relationship relationship, List<InstanceGroupInfo> instanceGroupInfoList) {
 436         if(relationship.getRelatedTo().equals("instance-group")){
 437             for(org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.RelatedToProperty relatedToProperty: relationship.getRelatedToPropertyList()){
 438                 if(relatedToProperty.getPropertyKey().equals("instance-group.instance-group-name")){
 439                     instanceGroupInfoList.add(new InstanceGroupInfo(relatedToProperty.getPropertyValue()));
 440                 }
 441             }
 442         }
 443     }
 444
 445     @Override
 446     public  List<PortDetailsTranslator.PortDetails> getPortMirroringSourcePorts(String configurationId){
 447         return aaiClient.getPortMirroringSourcePorts(configurationId);
 448     }
 449
 450     private void addPnfsToListViaDirectRelations(List<String> pnfs, AaiResponse<ServiceRelationships> serviceInstanceResp) {
 451         pnfs.addAll(getRelationshipDataByType(serviceInstanceResp.getT().getRelationshipList(), "pnf", "pnf.pnf-name"));
 452     }
 453
 454     private void addPnfsToListViaLogicalLinks(List<String> pnfs, AaiResponse<ServiceRelationships> serviceInstanceResp) {
 455         List<String> logicalLinks = getRelationshipDataByType(serviceInstanceResp.getT().getRelationshipList(), "logical-link", "logical-link.link-name");
 456         for (String logicalLink : logicalLinks) {
 457             String link;
 458             try {
 459                 link = URLEncoder.encode(logicalLink, "UTF-8");
 460             } catch (UnsupportedEncodingException e) {
 461                 LOGGER.error("Failed to encode logical link: " + logicalLink, e);
 462                 continue;
 463             }
 464
 465             AaiResponse<LogicalLinkResponse> logicalLinkResp = aaiClient.getLogicalLink(link);
 466             if (logicalLinkResp.getT() != null) {
 467                 //lag-interface is the key for pnf - approved by Bracha
 468                 List<String> linkPnfs = getRelationshipDataByType(logicalLinkResp.getT().getRelationshipList(), "lag-interface", "pnf.pnf-name");
 469                 if (!linkPnfs.isEmpty()) {
 470                     pnfs.addAll(linkPnfs);
 471                 } else {
 472                     LOGGER.warn("no pnf found for logical link " + logicalLink);
 473                 }
 474             } else {
 475                 if (logicalLinkResp.getErrorMessage() != null) {
 476                     LOGGER.error("get logical link " + logicalLink + " return error", logicalLinkResp.getErrorMessage());
 477                 } else {
 478                     LOGGER.warn("get logical link " + logicalLink + " return empty body");
 479                 }
 480             }
 481         }
 482     }
 483
 484     private List<String> getRelationshipDataByType(RelationshipList relationshipList, String relationshipType, String relationshipDataKey) {
 485         List<String> relationshipValues = new ArrayList<>();
 486         for (Relationship relationship : relationshipList.getRelationship()) {
 487             if (relationship.getRelatedTo().equals(relationshipType)) {
 488                 relationshipValues.addAll( relationship.getRelationDataList().stream()
 489                         .filter(rel -> rel.getRelationshipKey().equals(relationshipDataKey))
 490                         .map(RelationshipData::getRelationshipValue)
 491                         .collect(Collectors.toList())
 492                 );
 493             }
 494         }
 495
 496
 497         return relationshipValues;
 498     }
 499 }