Dont filter get_vnf_data_by_globalid_and_service_type_response results
[vid.git] / 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 static org.onap.vid.aai.AaiClient.QUERY_FORMAT_RESOURCE;
25 import static org.onap.vid.utils.KotlinUtilsKt.JACKSON_OBJECT_MAPPER;
26
27 import com.fasterxml.jackson.databind.JsonNode;
28 import java.io.UnsupportedEncodingException;
29 import java.net.URLEncoder;
30 import java.util.ArrayList;
31 import java.util.Collection;
32 import java.util.Collections;
33 import java.util.List;
34 import java.util.Map;
35 import java.util.Objects;
36 import java.util.concurrent.ExecutorService;
37 import java.util.stream.Collectors;
38 import javax.validation.constraints.NotNull;
39 import javax.ws.rs.core.Response;
40 import org.apache.commons.lang3.StringUtils;
41 import org.apache.http.HttpStatus;
42 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
43 import org.onap.vid.aai.AaiClientInterface;
44 import org.onap.vid.aai.AaiGetVnfResponse;
45 import org.onap.vid.aai.AaiResponse;
46 import org.onap.vid.aai.AaiResponseTranslator;
47 import org.onap.vid.aai.ExceptionWithRequestInfo;
48 import org.onap.vid.aai.ServiceInstance;
49 import org.onap.vid.aai.ServiceInstancesSearchResults;
50 import org.onap.vid.aai.ServiceSubscription;
51 import org.onap.vid.aai.ServiceSubscriptions;
52 import org.onap.vid.aai.Services;
53 import org.onap.vid.aai.SubscriberFilteredResults;
54 import org.onap.vid.aai.model.AaiGetInstanceGroupsByCloudRegion;
55 import org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.AaiGetRelatedInstanceGroupsByVnfId;
56 import org.onap.vid.aai.model.AaiGetOperationalEnvironments.OperationalEnvironmentList;
57 import org.onap.vid.aai.model.AaiGetPnfs.Pnf;
58 import org.onap.vid.aai.model.AaiGetServicesRequestModel.GetServicesAAIRespone;
59 import org.onap.vid.aai.model.AaiGetTenatns.GetTenantsResponse;
60 import org.onap.vid.aai.model.AaiRelationResponse;
61 import org.onap.vid.aai.model.GetServiceModelsByDistributionStatusResponse;
62 import org.onap.vid.aai.model.InstanceGroupInfo;
63 import org.onap.vid.aai.model.LogicalLinkResponse;
64 import org.onap.vid.aai.model.Model;
65 import org.onap.vid.aai.model.ModelVer;
66 import org.onap.vid.aai.model.OwningEntity;
67 import org.onap.vid.aai.model.OwningEntityResponse;
68 import org.onap.vid.aai.model.PortDetailsTranslator;
69 import org.onap.vid.aai.model.Project;
70 import org.onap.vid.aai.model.ProjectResponse;
71 import org.onap.vid.aai.model.Properties;
72 import org.onap.vid.aai.model.RelatedToProperty;
73 import org.onap.vid.aai.model.Relationship;
74 import org.onap.vid.aai.model.RelationshipData;
75 import org.onap.vid.aai.model.RelationshipList;
76 import org.onap.vid.aai.model.Result;
77 import org.onap.vid.aai.model.ServiceRelationships;
78 import org.onap.vid.asdc.beans.Service;
79 import org.onap.vid.exceptions.GenericUncheckedException;
80 import org.onap.vid.model.ServiceInstanceSearchResult;
81 import org.onap.vid.model.SubscriberList;
82 import org.onap.vid.model.aaiTree.AAITreeNode;
83 import org.onap.vid.model.aaiTree.Network;
84 import org.onap.vid.model.aaiTree.NodeType;
85 import org.onap.vid.model.aaiTree.RelatedVnf;
86 import org.onap.vid.model.aaiTree.VpnBinding;
87 import org.onap.vid.model.aaiTree.VpnBindingKt;
88 import org.onap.vid.roles.RoleValidator;
89 import org.onap.vid.utils.Intersection;
90 import org.onap.vid.utils.Tree;
91 import org.springframework.beans.factory.annotation.Autowired;
92 import org.springframework.http.HttpMethod;
93
94 public class AaiServiceImpl implements AaiService {
95     private static final String SERVICE_INSTANCE_ID = "service-instance.service-instance-id";
96     private static final String SERVICE_TYPE = "service-subscription.service-type";
97     private static final String CUSTOMER_ID = "customer.global-customer-id";
98     private static final String SERVICE_INSTANCE_NAME = "service-instance.service-instance-name";
99     private static final String TENANT_NODE_TYPE = "tenant";
100     private static final String CLOUD_REGION_NODE_TYPE = "cloud-region";
101     private int indexOfSubscriberName = 6;
102
103     private AaiClientInterface aaiClient;
104     private AaiResponseTranslator aaiResponseTranslator;
105     private AAIServiceTree aaiServiceTree;
106     private ExecutorService executorService;
107
108
109     private static final EELFLoggerDelegate LOGGER = EELFLoggerDelegate.getLogger(AaiServiceImpl.class);
110
111     @Autowired
112     public AaiServiceImpl(
113         AaiClientInterface aaiClient,
114         AaiResponseTranslator aaiResponseTranslator,
115         AAIServiceTree aaiServiceTree,
116         ExecutorService executorService)
117     {
118         this.aaiClient = aaiClient;
119         this.aaiResponseTranslator = aaiResponseTranslator;
120         this.aaiServiceTree = aaiServiceTree;
121         this.executorService = executorService;
122     }
123
124     private List<Service> convertModelToService(Model model) {
125         List<Service> services = new ArrayList<>();
126
127         if(validateModel(model)){
128             for (ModelVer modelVer: model.getModelVers().getModelVer()) {
129                 Service service = new Service.ServiceBuilder()
130                         .setUuid(modelVer.getModelVersionId())
131                         .setInvariantUUID(model.getModelInvariantId())
132                         .setCategory(model.getModelType() != null ? model.getModelType() : "")
133                         .setVersion(modelVer.getModelVersion())
134                         .setName( modelVer.getModelName())
135                         .setDistributionStatus(modelVer.getDistributionStatus())
136                         .setToscaModelURL(null)
137                         .setLifecycleState(null)
138                         .setArtifacts(null)
139                         .setResources(null)
140                         .setOrchestrationType(modelVer.getOrchestrationType())
141                         .build();
142
143
144
145                 services.add(service);
146             }
147         } else {
148             return Collections.emptyList();
149         }
150
151         return services;
152     }
153
154     private boolean hasData(AaiResponse<?> aaiResponse) {
155         return aaiResponse != null && aaiResponse.getT() != null;
156     }
157
158     private boolean validateModel(Model model){
159         if (model == null) {
160             return false;
161         } else {
162             return model.getModelVers() != null && model.getModelVers().getModelVer() != null && model.getModelVers().getModelVer().get(0).getModelVersionId() != null;
163         }
164     }
165
166     private List<ServiceInstanceSearchResult> getServicesByOwningEntityId(List<String> owningEntities, RoleValidator roleValidator) {
167         AaiResponse<OwningEntityResponse> owningEntityResponse = aaiClient.getServicesByOwningEntityId(owningEntities);
168         List<ServiceInstanceSearchResult> serviceInstanceSearchResultList = new ArrayList<>();
169         if (owningEntityResponse.getT() != null) {
170             for (OwningEntity owningEntity : owningEntityResponse.getT().getOwningEntity()) {
171                 if (owningEntity.getRelationshipList() != null) {
172                     serviceInstanceSearchResultList = convertRelationshipToSearchResult(owningEntity, serviceInstanceSearchResultList, roleValidator);
173                 }
174             }
175         }
176         return serviceInstanceSearchResultList;
177     }
178
179     private List<ServiceInstanceSearchResult> getServicesByProjectNames(List<String> projectNames, RoleValidator roleValidator) {
180         AaiResponse<ProjectResponse> projectByIdResponse = aaiClient.getServicesByProjectNames(projectNames);
181         List<ServiceInstanceSearchResult> serviceInstanceSearchResultList = new ArrayList<>();
182         if (projectByIdResponse.getT() != null) {
183             for (Project project : projectByIdResponse.getT().getProject()) {
184                 if (project.getRelationshipList() != null) {
185                     serviceInstanceSearchResultList = convertRelationshipToSearchResult(project, serviceInstanceSearchResultList, roleValidator);
186                 }
187             }
188         }
189         return serviceInstanceSearchResultList;
190     }
191
192     private List<ServiceInstanceSearchResult> convertRelationshipToSearchResult(AaiRelationResponse owningEntityResponse, List<ServiceInstanceSearchResult> serviceInstanceSearchResultList, RoleValidator roleValidator) {
193         if (owningEntityResponse.getRelationshipList().getRelationship() != null) {
194             List<Relationship> relationshipList = owningEntityResponse.getRelationshipList().getRelationship();
195             for (Relationship relationship : relationshipList) {
196                 ServiceInstanceSearchResult serviceInstanceSearchResult = new ServiceInstanceSearchResult();
197                 extractRelationshipData(relationship, serviceInstanceSearchResult, roleValidator);
198                 extractRelatedToProperty(relationship, serviceInstanceSearchResult);
199                 serviceInstanceSearchResultList.add(serviceInstanceSearchResult);
200             }
201         }
202         return serviceInstanceSearchResultList;
203     }
204
205     private void extractRelationshipData(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult, RoleValidator roleValidator) {
206         List<RelationshipData> relationshipDataList = relationship.getRelationDataList();
207         if (relationshipDataList != null) {
208             setSubscriberName(relationship, serviceInstanceSearchResult);
209             for (RelationshipData relationshipData : relationshipDataList) {
210                 String key = relationshipData.getRelationshipKey();
211                 if (key.equals(SERVICE_INSTANCE_ID)) {
212                     serviceInstanceSearchResult.setServiceInstanceId(relationshipData.getRelationshipValue());
213                 } else if (key.equals(SERVICE_TYPE)) {
214                     serviceInstanceSearchResult.setServiceType(relationshipData.getRelationshipValue());
215                 } else if (key.equals(CUSTOMER_ID)) {
216                     serviceInstanceSearchResult.setGlobalCustomerId(relationshipData.getRelationshipValue());
217                 }
218             }
219
220             boolean isPermitted = roleValidator.isServicePermitted(serviceInstanceSearchResult.getSubscriberName(), serviceInstanceSearchResult.getServiceType());
221             serviceInstanceSearchResult.setIsPermitted(isPermitted);
222         }
223     }
224
225     private void setSubscriberName(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult) {
226         String relatedLink = relationship.getRelatedLink();
227         String[] subsciber = relatedLink.split("/");
228         serviceInstanceSearchResult.setSubscriberName(subsciber[indexOfSubscriberName]);
229     }
230
231     private void extractRelatedToProperty(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult) {
232         List<RelatedToProperty> relatedToPropertyList = relationship.getRelatedToPropertyList();
233         if (relatedToPropertyList != null) {
234             for (RelatedToProperty relatedToProperty : relatedToPropertyList) {
235                 if (relatedToProperty.getPropertyKey().equals(SERVICE_INSTANCE_NAME)) {
236                     serviceInstanceSearchResult.setServiceInstanceName(relatedToProperty.getPropertyValue());
237                 }
238             }
239         }
240     }
241
242     @Override
243     public SubscriberFilteredResults getFullSubscriberList(RoleValidator roleValidator) {
244         AaiResponse<SubscriberList> subscriberResponse = aaiClient.getAllSubscribers();
245
246         return new SubscriberFilteredResults(roleValidator, subscriberResponse.getT(),
247                 subscriberResponse.getErrorMessage(),
248                 subscriberResponse.getHttpCode());
249     }
250
251     @Override
252     public AaiResponse<OperationalEnvironmentList> getOperationalEnvironments(String operationalEnvironmentType, String operationalEnvironmentStatus) {
253         return aaiClient.getOperationalEnvironments(operationalEnvironmentType, operationalEnvironmentStatus);
254     }
255
256     @Override
257     public AaiResponse<SubscriberList> getFullSubscriberList() {
258         return aaiClient.getAllSubscribers();
259     }
260
261     @Override
262     public AaiResponse getSubscriberData(String subscriberId, RoleValidator roleValidator, boolean omitServiceInstances) {
263         AaiResponse<Services> subscriberResponse = aaiClient.getSubscriberData(subscriberId, omitServiceInstances);
264         String subscriberGlobalId = subscriberResponse.getT().globalCustomerId;
265         for (ServiceSubscription serviceSubscription : subscriberResponse.getT().serviceSubscriptions.serviceSubscription) {
266             String serviceType = serviceSubscription.serviceType;
267             serviceSubscription.isPermitted = roleValidator.isServicePermitted(subscriberGlobalId, serviceType);
268         }
269         return subscriberResponse;
270
271     }
272
273     @Override
274     public AaiResponse getServiceInstanceSearchResults(String subscriberId, String instanceIdentifier, RoleValidator roleValidator, List<String> owningEntities, List<String> projects) {
275         List<List<ServiceInstanceSearchResult>> resultList = new ArrayList<>();
276         ServiceInstancesSearchResults serviceInstancesSearchResults = new ServiceInstancesSearchResults();
277
278         if (subscriberId != null || instanceIdentifier != null) {
279             resultList.add(getServicesBySubscriber(subscriberId, instanceIdentifier, roleValidator));
280         }
281         if (owningEntities != null) {
282             resultList.add(getServicesByOwningEntityId(owningEntities, roleValidator));
283         }
284         if (projects != null) {
285             resultList.add(getServicesByProjectNames(projects, roleValidator));
286         }
287         if (!resultList.isEmpty()) {
288             serviceInstancesSearchResults.serviceInstances = Intersection.of(resultList);
289         }
290
291         return new AaiResponse<>(serviceInstancesSearchResults, null, HttpStatus.SC_OK);
292     }
293
294
295     private List<ServiceInstanceSearchResult> getServicesBySubscriber(String subscriberId, String instanceIdentifier, RoleValidator roleValidator) {
296         AaiResponse<Services> subscriberResponse = aaiClient.getSubscriberData(subscriberId, false);
297         String subscriberGlobalId = subscriberResponse.getT().globalCustomerId;
298         String subscriberName = subscriberResponse.getT().subscriberName;
299         ServiceSubscriptions serviceSubscriptions = subscriberResponse.getT().serviceSubscriptions;
300
301         return getSearchResultsForSubscriptions(serviceSubscriptions, subscriberId, instanceIdentifier, roleValidator, subscriberGlobalId, subscriberName);
302
303     }
304
305
306     private ArrayList<ServiceInstanceSearchResult> getSearchResultsForSubscriptions(ServiceSubscriptions serviceSubscriptions, String subscriberId, String instanceIdentifier, RoleValidator roleValidator, String subscriberGlobalId, String subscriberName) {
307         ArrayList<ServiceInstanceSearchResult> results = new ArrayList<>();
308
309         if (serviceSubscriptions != null) {
310             for (ServiceSubscription serviceSubscription : serviceSubscriptions.serviceSubscription) {
311                 String serviceType = serviceSubscription.serviceType;
312                 serviceSubscription.isPermitted = roleValidator.isServicePermitted(subscriberGlobalId, serviceType);
313                 ArrayList<ServiceInstanceSearchResult> resultsForSubscription = getSearchResultsForSingleSubscription(serviceSubscription, subscriberId, instanceIdentifier, subscriberName, serviceType);
314                 results.addAll(resultsForSubscription);
315             }
316         }
317
318         return results;
319     }
320
321     private ArrayList<ServiceInstanceSearchResult> getSearchResultsForSingleSubscription(ServiceSubscription serviceSubscription, String subscriberId, String instanceIdentifier, String subscriberName, String serviceType) {
322         ArrayList<ServiceInstanceSearchResult> results = new ArrayList<>();
323
324         if (serviceSubscription.serviceInstances != null) {
325             for (ServiceInstance serviceInstance : serviceSubscription.serviceInstances.serviceInstance) {
326                 ServiceInstanceSearchResult serviceInstanceSearchResult =
327                         new ServiceInstanceSearchResult(serviceInstance.serviceInstanceId, subscriberId, serviceType, serviceInstance.serviceInstanceName,
328                                 subscriberName, serviceInstance.modelInvariantId, serviceInstance.modelVersionId, serviceSubscription.isPermitted);
329
330                 if ((instanceIdentifier == null) || (serviceInstanceMatchesIdentifier(instanceIdentifier, serviceInstance))){
331                     results.add(serviceInstanceSearchResult);
332                 }
333             }
334         }
335
336         return results;
337     }
338
339     private boolean serviceInstanceMatchesIdentifier(String instanceIdentifier, ServiceInstance serviceInstance) {
340         return instanceIdentifier.equals(serviceInstance.serviceInstanceId) || instanceIdentifier.equals(serviceInstance.serviceInstanceName);
341     }
342
343     @Override
344     public Response getVersionByInvariantId(List<String> modelInvariantId) {
345         try {
346             return aaiClient.getVersionByInvariantId(modelInvariantId);
347         } catch (Exception e) {
348             LOGGER.error(EELFLoggerDelegate.errorLogger, "Failed to getVersionByInvariantId from A&AI", e);
349         }
350         return null;
351     }
352
353     @Override
354     public AaiResponse<Pnf> getSpecificPnf(String pnfId) {
355         return aaiClient.getSpecificPnf(pnfId);
356     }
357
358     @Override
359     public AaiResponse getPNFData(String globalCustomerId, String serviceType, String modelVersionId, String modelInvariantId, String cloudRegion, String equipVendor, String equipModel) {
360         return aaiClient.getPNFData(globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion, equipVendor, equipModel);
361     }
362
363
364
365     @Override
366     public AaiResponse getServices(RoleValidator roleValidator) {
367         AaiResponse<GetServicesAAIRespone> subscriberResponse = aaiClient.getServices();
368         if (subscriberResponse.getT() != null) {
369             for (org.onap.vid.aai.model.AaiGetServicesRequestModel.Service service : subscriberResponse.getT().service) {
370                 service.isPermitted = true;
371             }
372         }
373         return subscriberResponse;
374     }
375
376     @Override
377     public AaiResponse<GetTenantsResponse[]> getTenants(String globalCustomerId, String serviceType, RoleValidator roleValidator) {
378         AaiResponse<GetTenantsResponse[]> aaiGetTenantsResponse = aaiClient.getTenants(globalCustomerId, serviceType);
379         GetTenantsResponse[] tenants = aaiGetTenantsResponse.getT();
380         if (tenants != null) {
381             for (GetTenantsResponse tenant : tenants) {
382                 tenant.isPermitted = roleValidator.isTenantPermitted(globalCustomerId, serviceType, tenant.tenantName);
383             }
384         }
385         return aaiGetTenantsResponse;
386     }
387
388     @Override
389     public AaiResponse getVNFData(String globalSubscriberId, String serviceType, String serviceInstanceId) {
390         return aaiClient.getVNFData(globalSubscriberId, serviceType, serviceInstanceId);
391     }
392
393     @Override
394     public AaiResponse<AaiGetVnfResponse> getVNFData(String globalSubscriberId, String serviceType) {
395         AaiResponse<AaiGetVnfResponse> response = aaiClient.getVNFData(globalSubscriberId, serviceType);
396         return hasData(response) ? response : new AaiResponse<>();
397     }
398
399     @Override
400     public AaiResponse getAaiZones() {
401         return aaiClient.getAllAicZones();
402     }
403
404     @Override
405     public AaiResponse getAicZoneForPnf(String globalCustomerId, String serviceType, String serviceId) {
406         String aicZone = "";
407
408         AaiResponse<ServiceRelationships> serviceInstanceResp = aaiClient.getServiceInstance(globalCustomerId, serviceType, serviceId);
409         if (serviceInstanceResp.getT() != null) {
410             List<String> aicZoneList = getRelationshipDataByType(serviceInstanceResp.getT().getRelationshipList(), "zone", "zone.zone-id");
411             if (!aicZoneList.isEmpty()) {
412                 aicZone = aicZoneList.get(0);
413             } else {
414                 LOGGER.warn("aic zone not found for service instance " + serviceId);
415             }
416         } else {
417             if (serviceInstanceResp.getErrorMessage() != null) {
418                 LOGGER.error("get service instance {} return error {}", serviceId, serviceInstanceResp.getErrorMessage());
419                 return new AaiResponse(aicZone , serviceInstanceResp.getErrorMessage() ,serviceInstanceResp.getHttpCode());
420             } else {
421                 LOGGER.warn("get service instance {} return empty body", serviceId);
422                 return new AaiResponse(aicZone , "get service instance " + serviceId + " return empty body" ,serviceInstanceResp.getHttpCode());
423             }
424         }
425
426         return new AaiResponse(aicZone , null ,HttpStatus.SC_OK);
427     }
428
429     @Override
430     public AaiResponse getNodeTemplateInstances(String globalCustomerId, String serviceType, String modelVersionId, String modelInvariantId, String cloudRegion) {
431         return aaiClient.getNodeTemplateInstances(globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion);
432     }
433
434     @Override
435     public AaiResponse getNetworkCollectionDetails(String serviceInstanceId){
436         return aaiClient.getNetworkCollectionDetails(serviceInstanceId);
437     }
438
439     @Override
440     public AaiResponse<AaiGetInstanceGroupsByCloudRegion> getInstanceGroupsByCloudRegion(String cloudOwner, String cloudRegionId, String networkFunction){
441         return aaiClient.getInstanceGroupsByCloudRegion(cloudOwner, cloudRegionId, networkFunction);
442     }
443
444     @Override
445     public Collection<Service> getServicesByDistributionStatus() {
446         AaiResponse<GetServiceModelsByDistributionStatusResponse> serviceModelsByDistributionStatusResponse = aaiClient.getServiceModelsByDistributionStatus();
447         Collection<Service> services = new ArrayList<>();
448         if (serviceModelsByDistributionStatusResponse.getT() != null) {
449             List<Result> results = serviceModelsByDistributionStatusResponse.getT().getResults();
450             for (Result result : results) {
451                 if(result.getModel() != null) {
452                     List<Service> service = convertModelToService(result.getModel());
453                     services.addAll(service);
454                 }
455             }
456         }
457         return services;
458     }
459
460     @Override
461     public List<String> getServiceInstanceAssociatedPnfs(String globalCustomerId, String serviceType, String serviceInstanceId) {
462         List<String> pnfs = new ArrayList<>();
463
464         AaiResponse<ServiceRelationships> serviceInstanceResp = aaiClient.getServiceInstance(globalCustomerId, serviceType, serviceInstanceId);
465         if (serviceInstanceResp.getT() != null) {
466
467             addPnfsToListViaLogicalLinks(pnfs, serviceInstanceResp);
468             addPnfsToListViaDirectRelations(pnfs, serviceInstanceResp);
469
470             if (pnfs.isEmpty()) {
471                 LOGGER.warn("no pnf direct relation found for service id:" + serviceInstanceId+
472                         " name: "+serviceInstanceResp.getT().getServiceInstanceName());
473             }
474         } else {
475             if (serviceInstanceResp.getErrorMessage() != null) {
476                 LOGGER.error("get service instance {} return error {}", serviceInstanceId, serviceInstanceResp.getErrorMessage());
477             } else {
478                 LOGGER.warn("get service instance {} return empty body", serviceInstanceId);
479             }
480         }
481
482         return pnfs.stream().distinct().collect(Collectors.toList());
483     }
484
485     @Override
486     public AaiResponseTranslator.PortMirroringConfigData getPortMirroringConfigData(String configurationId) {
487         AaiResponse<JsonNode> aaiResponse = aaiClient.getCloudRegionAndSourceByPortMirroringConfigurationId(configurationId);
488         return aaiResponseTranslator.extractPortMirroringConfigData(aaiResponse);
489     }
490
491     @Override
492     public AaiResponse getInstanceGroupsByVnfInstanceId(String vnfInstanceId){
493         AaiResponse<AaiGetRelatedInstanceGroupsByVnfId> aaiResponse = aaiClient.getInstanceGroupsByVnfInstanceId(vnfInstanceId);
494         if(aaiResponse.getHttpCode() == HttpStatus.SC_OK){
495             return new AaiResponse<>(convertGetInstanceGroupsResponseToSimpleResponse(aaiResponse.getT()), aaiResponse.getErrorMessage(), aaiResponse.getHttpCode());
496         }
497         return aaiResponse;
498     }
499
500     @Override
501     public GetTenantsResponse getHomingDataByVfModule(String vnfInstanceId, String vfModuleId) {
502         return aaiClient.getHomingDataByVfModule(vnfInstanceId,vfModuleId);
503     }
504
505     @Override
506     public List<RelatedVnf> searchGroupMembers(String globalCustomerId, String serviceType, String invariantId, String groupType, String groupRole) {
507         String getURL = "business/customers/customer/" +
508                 globalCustomerId + "/service-subscriptions/service-subscription/" +
509                 serviceType + "/service-instances?model-invariant-id=" + invariantId;
510
511         Tree<AAIServiceTree.AaiRelationship> pathsToSearch = new Tree<>(new AAIServiceTree.AaiRelationship(NodeType.SERVICE_INSTANCE));
512         pathsToSearch.addPath(AAIServiceTree.toAaiRelationshipList(NodeType.GENERIC_VNF, NodeType.INSTANCE_GROUP));
513
514         //get all vnfs related to service-instances from the model-invariant-id
515         List<AAITreeNode> aaiTree = aaiServiceTree.buildAAITree(getURL, null, HttpMethod.GET, pathsToSearch, true);
516
517         //filter by instance-group-role & instance-group-type properties (from getAdditionalProperties)
518         //only vnfs has related instance-group with the same groupType & groupRole - are filtered out.
519         List<AAITreeNode> filteredVnfs = filterByInstanceGroupRoleAndType(aaiTree, groupRole, groupType);
520
521         //convert vnfs to expected result
522         List<RelatedVnf> convertedVnfs = filteredVnfs.stream()
523                 .map(RelatedVnf::from)
524                 .collect(Collectors.toList());
525
526         try {
527             return executorService.submit(() ->
528                     convertedVnfs.parallelStream()
529                             .map(this::enrichRelatedVnfWithCloudRegionAndTenant)
530                             .collect(Collectors.toList())
531             ).get();
532         } catch (Exception e) {
533             LOGGER.error(EELFLoggerDelegate.errorLogger, "Search group Members - Failed to enrich vnf with cloud region", e);
534             return convertedVnfs;
535         }
536     }
537
538     private List<AAITreeNode> filterByInstanceGroupRoleAndType(List<AAITreeNode> aaiTree, String groupRole, String groupType) {
539
540         return aaiTree.stream()
541                 .map(AAITreeNode::getChildren)
542                 .flatMap(Collection::stream)
543                 .filter(vnf -> isInstanceGroupsNotMatchRoleAndType(vnf.getChildren(), groupRole, groupType))
544                 .collect(Collectors.toList());
545     }
546
547     public boolean isInstanceGroupsNotMatchRoleAndType(List<AAITreeNode> instanceGroups, String groupRole, String groupType) {
548         return instanceGroups.stream()
549                 .map(AAITreeNode::getAdditionalProperties)
550                 .allMatch(props ->
551                         (!(groupRole.equals(props.get("instance-group-role")) &&
552                                 groupType.equals(props.get("instance-group-type"))))
553                 );
554     }
555
556     public RelatedVnf enrichRelatedVnfWithCloudRegionAndTenant(RelatedVnf vnf) {
557         Map<String, Properties> cloudRegionAndTenant = aaiClient.getCloudRegionAndTenantByVnfId(vnf.getInstanceId());
558
559         if (cloudRegionAndTenant.containsKey(TENANT_NODE_TYPE)) {
560             vnf.setTenantId(cloudRegionAndTenant.get(TENANT_NODE_TYPE).getTenantId());
561             vnf.setTenantName(cloudRegionAndTenant.get(TENANT_NODE_TYPE).getTenantName());
562         }
563
564         if (cloudRegionAndTenant.containsKey(CLOUD_REGION_NODE_TYPE)) {
565             vnf.setLcpCloudRegionId(cloudRegionAndTenant.get(CLOUD_REGION_NODE_TYPE).getCloudRegionId());
566         }
567
568         return vnf;
569     }
570
571     private List<InstanceGroupInfo> convertGetInstanceGroupsResponseToSimpleResponse(AaiGetRelatedInstanceGroupsByVnfId response) {
572         List<InstanceGroupInfo> instanceGroupInfoList = new ArrayList<>();
573         for(org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Relationship relationship: response.getRelationshipList().getRelationship()){
574             getInstanceGroupInfoFromRelationship(relationship, instanceGroupInfoList);
575         }
576         return instanceGroupInfoList;
577     }
578
579     private void getInstanceGroupInfoFromRelationship(org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Relationship relationship, List<InstanceGroupInfo> instanceGroupInfoList) {
580         if(StringUtils.equals(relationship.getRelatedTo(),"instance-group")){
581             for(org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.RelatedToProperty relatedToProperty: relationship.getRelatedToPropertyList()){
582                 if(StringUtils.equals(relatedToProperty.getKey(),"instance-group.instance-group-name")){
583                     instanceGroupInfoList.add(new InstanceGroupInfo(relatedToProperty.getValue()));
584                 }
585             }
586         }
587     }
588
589     @Override
590     public  List<PortDetailsTranslator.PortDetails> getPortMirroringSourcePorts(String configurationId){
591         return aaiClient.getPortMirroringSourcePorts(configurationId);
592     }
593
594     private void addPnfsToListViaDirectRelations(List<String> pnfs, AaiResponse<ServiceRelationships> serviceInstanceResp) {
595         pnfs.addAll(getRelationshipDataByType(serviceInstanceResp.getT().getRelationshipList(), "pnf", "pnf.pnf-name"));
596     }
597
598     private void addPnfsToListViaLogicalLinks(List<String> pnfs, AaiResponse<ServiceRelationships> serviceInstanceResp) {
599         List<String> logicalLinks = getRelationshipDataByType(serviceInstanceResp.getT().getRelationshipList(), "logical-link", "logical-link.link-name");
600         for (String logicalLink : logicalLinks) {
601             String link;
602             try {
603                 link = URLEncoder.encode(logicalLink, "UTF-8");
604             } catch (UnsupportedEncodingException e) {
605                 LOGGER.error("Failed to encode logical link: " + logicalLink, e);
606                 continue;
607             }
608
609             AaiResponse<LogicalLinkResponse> logicalLinkResp = aaiClient.getLogicalLink(link);
610             if (logicalLinkResp.getT() != null) {
611                 //lag-interface is the key for pnf - approved by Bracha
612                 List<String> linkPnfs = getRelationshipDataByType(logicalLinkResp.getT().getRelationshipList(), "lag-interface", "pnf.pnf-name");
613                 if (!linkPnfs.isEmpty()) {
614                     pnfs.addAll(linkPnfs);
615                 } else {
616                     LOGGER.warn("no pnf found for logical link " + logicalLink);
617                 }
618             } else {
619                 if (logicalLinkResp.getErrorMessage() != null) {
620                     LOGGER.error("get logical link " + logicalLink + " return error", logicalLinkResp.getErrorMessage());
621                 } else {
622                     LOGGER.warn("get logical link " + logicalLink + " return empty body");
623                 }
624             }
625         }
626     }
627
628     private List<String> getRelationshipDataByType(RelationshipList relationshipList, String relationshipType, String relationshipDataKey) {
629         List<String> relationshipValues = new ArrayList<>();
630         for (Relationship relationship : relationshipList.getRelationship()) {
631             if (relationship.getRelatedTo().equals(relationshipType)) {
632                 relationshipValues.addAll( relationship.getRelationDataList().stream()
633                         .filter(rel -> rel.getRelationshipKey().equals(relationshipDataKey))
634                         .map(RelationshipData::getRelationshipValue)
635                         .collect(Collectors.toList())
636                 );
637             }
638         }
639
640
641         return relationshipValues;
642     }
643
644     public String getAAIServiceTree(String globalCustomerId, String serviceType, String serviceInstanceId) {
645         String result;
646         try {
647             org.onap.vid.model.aaiTree.ServiceInstance tree = aaiServiceTree.getServiceInstanceTopology(globalCustomerId, serviceType, serviceInstanceId);
648             result = JACKSON_OBJECT_MAPPER.writeValueAsString(tree);
649         } catch (Exception e) {
650             throw new GenericUncheckedException(e);
651         }
652         return result;
653     }
654
655     @Override
656     public List<VpnBinding> getVpnListByVpnType(String vpnType) {
657         String path = "network/vpn-bindings?vpn-type=" + vpnType;
658
659         try {
660             List<AAITreeNode> aaiTree = aaiServiceTree.buildAAITreeForUniqueResource(path, NodeType.VPN_BINDING);
661             return aaiTree.stream().map(VpnBindingKt::from).collect(Collectors.toList());
662         } catch (ExceptionWithRequestInfo exception) {
663             if (Objects.equals(404, exception.getHttpCode())) {
664                 return Collections.emptyList();
665             }
666             throw exception;
667         }
668
669     }
670
671     @Override
672     public List<Network> getL3NetworksByCloudRegion(String cloudRegionId, String tenantId, String networkRole) {
673         String payload = buildPayloadForL3NetworksByCloudRegion(cloudRegionId, tenantId, networkRole);
674
675         try {
676             List<AAITreeNode> aaiTree = aaiServiceTree.buildAAITreeForUniqueResourceFromCustomQuery(QUERY_FORMAT_RESOURCE, payload, HttpMethod.PUT, NodeType.NETWORK);
677             return aaiTree.stream().map(Network::from).collect(Collectors.toList());
678         } catch (ExceptionWithRequestInfo exception) {
679             if (Objects.equals(404, exception.getHttpCode())) {
680                 return Collections.emptyList();
681             }
682             throw exception;
683         }
684     }
685
686     @NotNull
687     protected String buildPayloadForL3NetworksByCloudRegion(String cloudRegionId, String tenantId, String networkRole) {
688         String networkRolePart = StringUtils.isEmpty(networkRole) ? "" : "&networkRole=" + networkRole;
689         String cloudOwner = aaiClient.getCloudOwnerByCloudRegionId(cloudRegionId);
690         return "{\"start\":\"/cloud-infrastructure/cloud-regions/cloud-region/" + cloudOwner + "/" + cloudRegionId + "\"," +
691                 "\"query\":\"query/l3-networks-by-cloud-region?tenantId=" + tenantId + networkRolePart + "\"}";
692     }
693
694     @Override
695     public ModelVer getNewestModelVersionByInvariantId(String modelInvariantId){
696         return aaiClient.getLatestVersionByInvariantId(modelInvariantId);
697     }
698 }