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.onap.vid.aai.model.AaiGetAicZone.AicZones;
   5 import org.openecomp.portalsdk.core.logging.logic.EELFLoggerDelegate;
   6 import org.onap.vid.aai.*;
   7 import org.onap.vid.aai.ServiceInstance;
   8 import org.onap.vid.aai.ServiceSubscription;
   9 import org.onap.vid.aai.Services;
  10 import org.onap.vid.aai.model.AaiGetOperationalEnvironments.OperationalEnvironmentList;
  11 import org.onap.vid.aai.model.AaiGetPnfs.Pnf;
  12 import org.onap.vid.aai.model.AaiGetServicesRequestModel.GetServicesAAIRespone;
  13 import org.onap.vid.aai.model.AaiGetTenatns.GetTenantsResponse;
  14 import org.onap.vid.aai.model.*;
  15 import org.onap.vid.asdc.beans.Service;
  16 import org.onap.vid.model.ServiceInstanceSearchResult;
  17 import org.onap.vid.model.SubscriberList;
  18 import org.onap.vid.roles.RoleValidator;
  19 import org.onap.vid.utils.Intersection;
  20 import org.springframework.beans.factory.annotation.Autowired;
  21
  22 import javax.ws.rs.core.Response;
  23 import java.io.UnsupportedEncodingException;
  24 import java.net.URLEncoder;
  25 import java.util.ArrayList;
  26 import java.util.Collection;
  27 import java.util.List;
  28 import java.util.stream.Collectors;
  29
  30 /**
  31  * Created by Oren on 7/4/17.
  32  */
  33 public class AaiServiceImpl implements AaiService {
  34     private String serviceInstanceId = "service-instance.service-instance-id";
  35     private String serviceType = "service-subscription.service-type";
  36     private String customerId = "customer.global-customer-id";
  37     private String serviceInstanceName = "service-instance.service-instance-name";
  38     private int indexOfSubscriberName = 6;
  39
  40     @Autowired
  41     private AaiClientInterface aaiClient;
  42
  43     EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(AaiServiceImpl.class);
  44
  45     private List<Service> convertModelToService(Model model) {
  46         List<Service> services = new ArrayList<>();
  47         String category = "";
  48
  49         if(validateModel(model)){
  50             if(model.getModelType() != null)
  51                 category = model.getModelType();
  52
  53             for (ModelVer modelVer: model.getModelVers().getModelVer()) {
  54                 Service service = new Service();
  55                 if (modelVer.getModelVersionId() != null)
  56                     service.setUuid(modelVer.getModelVersionId());
  57                 if(model.getModelInvariantId() != null)
  58                     service.setInvariantUUID(model.getModelInvariantId());
  59                 if(modelVer.getModelVersion() != null)
  60                     service.setVersion(modelVer.getModelVersion());
  61                 if(modelVer.getModelName() != null)
  62                     service.setName(modelVer.getModelName());
  63                 if(modelVer.getDistributionStatus() != null)
  64                     service.setDistributionStatus(Service.DistributionStatus.valueOf(modelVer.getDistributionStatus()));
  65                 service.setCategory(category);
  66
  67                 services.add(service);
  68             }
  69         } else {
  70             return null;
  71         }
  72
  73         return services;
  74     }
  75
  76     private boolean validateModel(Model model){
  77         if(model != null){
  78             if(model.getModelVers() != null && model.getModelVers().getModelVer() != null && model.getModelVers().getModelVer().get(0).getModelVersionId() != null){
  79                 return true;
  80             }
  81         }
  82         return false;
  83     }
  84
  85     private List<ServiceInstanceSearchResult> getServicesByOwningEntityId(List<String> owningEntities, RoleValidator roleValidator) {
  86         AaiResponse<OwningEntityResponse> owningEntityResponse = aaiClient.getServicesByOwningEntityId(owningEntities);
  87         List<ServiceInstanceSearchResult> serviceInstanceSearchResultList = new ArrayList<>();
  88         if (owningEntityResponse.getT() != null) {
  89             for (OwningEntity owningEntity : owningEntityResponse.getT().getOwningEntity()) {
  90                 if (owningEntity.getRelationshipList() != null) {
  91                     serviceInstanceSearchResultList = convertRelationshipToSearchResult(owningEntity, serviceInstanceSearchResultList, roleValidator);
  92                 }
  93             }
  94         }
  95         return serviceInstanceSearchResultList;
  96     }
  97
  98     private List<ServiceInstanceSearchResult> getServicesByProjectNames(List<String> projectNames, RoleValidator roleValidator) {
  99         AaiResponse<ProjectResponse> projectByIdResponse = aaiClient.getServicesByProjectNames(projectNames);
 100         List<ServiceInstanceSearchResult> serviceInstanceSearchResultList = new ArrayList<>();
 101         if (projectByIdResponse.getT() != null) {
 102             for (Project project : projectByIdResponse.getT().getProject()) {
 103                 if (project.getRelationshipList() != null)
 104                     serviceInstanceSearchResultList = convertRelationshipToSearchResult(project, serviceInstanceSearchResultList, roleValidator);
 105             }
 106         }
 107         return serviceInstanceSearchResultList;
 108     }
 109
 110     private List<ServiceInstanceSearchResult> convertRelationshipToSearchResult(AaiRelationResponse owningEntityResponse, List<ServiceInstanceSearchResult> serviceInstanceSearchResultList, RoleValidator roleValidator) {
 111         if (owningEntityResponse.getRelationshipList().getRelationship() != null) {
 112             List<Relationship> relationshipList = owningEntityResponse.getRelationshipList().getRelationship();
 113             for (Relationship relationship : relationshipList) {
 114                 ServiceInstanceSearchResult serviceInstanceSearchResult = new ServiceInstanceSearchResult();
 115                 extractRelationshipData(relationship, serviceInstanceSearchResult, roleValidator);
 116                 extractRelatedToProperty(relationship, serviceInstanceSearchResult);
 117                 serviceInstanceSearchResultList.add(serviceInstanceSearchResult);
 118             }
 119         }
 120         return serviceInstanceSearchResultList;
 121     }
 122
 123     private void extractRelationshipData(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult, RoleValidator roleValidator) {
 124         List<RelationshipData> relationshipDataList = relationship.getRelationDataList();
 125         if (relationshipDataList != null) {
 126             setSubscriberName(relationship, serviceInstanceSearchResult);
 127             for (RelationshipData relationshipData : relationshipDataList) {
 128                 String key = relationshipData.getRelationshipKey();
 129                 if (key.equals(serviceInstanceId)) {
 130                     serviceInstanceSearchResult.setServiceInstanceId(relationshipData.getRelationshipValue());
 131                 } else if (key.equals(serviceType)) {
 132                     serviceInstanceSearchResult.setServiceType(relationshipData.getRelationshipValue());
 133                 } else if (key.equals(customerId)) {
 134                     serviceInstanceSearchResult.setGlobalCustomerId(relationshipData.getRelationshipValue());
 135                 }
 136             }
 137
 138             boolean isPermitted = roleValidator.isServicePermitted(serviceInstanceSearchResult.getSubscriberName(), serviceInstanceSearchResult.getServiceType());
 139             serviceInstanceSearchResult.setIsPermitted(isPermitted);
 140         }
 141     }
 142
 143     private void setSubscriberName(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult) {
 144         String relatedLink = relationship.getRelatedLink();
 145         String[] subsciber = relatedLink.split("/");
 146         serviceInstanceSearchResult.setSubscriberName(subsciber[indexOfSubscriberName]);
 147     }
 148
 149     private void extractRelatedToProperty(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult) {
 150         List<RelatedToProperty> relatedToPropertyList = relationship.getRelatedToPropertyList();
 151         if (relatedToPropertyList != null) {
 152             for (RelatedToProperty relatedToProperty : relatedToPropertyList) {
 153                 if (relatedToProperty.getPropertyKey().equals(serviceInstanceName)) {
 154                     serviceInstanceSearchResult.setServiceInstanceName(relatedToProperty.getPropertyValue());
 155                 }
 156             }
 157         }
 158     }
 159
 160     @Override
 161     public SubscriberFilteredResults getFullSubscriberList(RoleValidator roleValidator) {
 162         AaiResponse<SubscriberList> subscriberResponse = aaiClient.getAllSubscribers();
 163         SubscriberFilteredResults subscriberFilteredResults =
 164                 new SubscriberFilteredResults(roleValidator, subscriberResponse.getT(),
 165                         subscriberResponse.getErrorMessage(),
 166                         subscriberResponse.getHttpCode());
 167
 168         return subscriberFilteredResults;
 169     }
 170
 171     @Override
 172     public AaiResponse<OperationalEnvironmentList> getOperationalEnvironments(String operationalEnvironmentType, String operationalEnvironmentStatus) {
 173         AaiResponse<OperationalEnvironmentList> subscriberResponse = aaiClient.getOperationalEnvironments(operationalEnvironmentType, operationalEnvironmentStatus);
 174         return subscriberResponse;
 175     }
 176
 177     @Override
 178     public AaiResponse<SubscriberList> getFullSubscriberList() {
 179         AaiResponse<SubscriberList> subscriberResponse = aaiClient.getAllSubscribers();
 180         return subscriberResponse;
 181     }
 182
 183     @Override
 184     public AaiResponse getSubscriberData(String subscriberId, RoleValidator roleValidator) {
 185         AaiResponse<Services> subscriberResponse = aaiClient.getSubscriberData(subscriberId);
 186         String subscriberGlobalId = subscriberResponse.getT().globalCustomerId;
 187         for (ServiceSubscription serviceSubscription : subscriberResponse.getT().serviceSubscriptions.serviceSubscription) {
 188             String serviceType = serviceSubscription.serviceType;
 189             serviceSubscription.isPermitted = roleValidator.isServicePermitted(subscriberGlobalId, serviceType);
 190         }
 191         return subscriberResponse;
 192
 193     }
 194
 195     @Override
 196     public AaiResponse getServiceInstanceSearchResults(String subscriberId, String instanceIdentifier, RoleValidator roleValidator, List<String> owningEntities, List<String> projects) {
 197         List<List<ServiceInstanceSearchResult>> resultList = new ArrayList<>();
 198         ServiceInstancesSearchResults serviceInstancesSearchResults = new ServiceInstancesSearchResults();
 199
 200         if (subscriberId != null || instanceIdentifier != null) {
 201             resultList.add(getServicesBySubscriber(subscriberId, instanceIdentifier, roleValidator));
 202         }
 203         if (owningEntities != null) {
 204             resultList.add(getServicesByOwningEntityId(owningEntities, roleValidator));
 205         }
 206         if (projects != null) {
 207             resultList.add(getServicesByProjectNames(projects, roleValidator));
 208         }
 209         if (resultList.size() > 0) {
 210             Intersection<ServiceInstanceSearchResult> intersection = new Intersection<>();
 211             serviceInstancesSearchResults.serviceInstances = intersection.intersectMultipileArray(resultList);
 212         }
 213
 214         return new AaiResponse<>(serviceInstancesSearchResults, null, HttpStatus.SC_OK);
 215     }
 216
 217
 218     private List<ServiceInstanceSearchResult> getServicesBySubscriber(String subscriberId, String instanceIdentifier, RoleValidator roleValidator) {
 219         AaiResponse<Services> subscriberResponse = aaiClient.getSubscriberData(subscriberId);
 220         String subscriberGlobalId = subscriberResponse.getT().globalCustomerId;
 221         String subscriberName = subscriberResponse.getT().subscriberName;
 222         ServiceSubscriptions serviceSubscriptions = subscriberResponse.getT().serviceSubscriptions;
 223
 224         return getSearchResultsForSubscriptions(serviceSubscriptions, subscriberId, instanceIdentifier, roleValidator, subscriberGlobalId, subscriberName);
 225
 226     }
 227
 228
 229     private ArrayList<ServiceInstanceSearchResult> getSearchResultsForSubscriptions(ServiceSubscriptions serviceSubscriptions, String subscriberId, String instanceIdentifier, RoleValidator roleValidator, String subscriberGlobalId, String subscriberName) {
 230         ArrayList<ServiceInstanceSearchResult> results = new ArrayList<>();
 231
 232         if (serviceSubscriptions != null) {
 233             for (ServiceSubscription serviceSubscription : serviceSubscriptions.serviceSubscription) {
 234                 String serviceType = serviceSubscription.serviceType;
 235                 serviceSubscription.isPermitted = roleValidator.isServicePermitted(subscriberGlobalId, serviceType);
 236                 ArrayList<ServiceInstanceSearchResult> resultsForSubscription = getSearchResultsForSingleSubscription(serviceSubscription, subscriberId, instanceIdentifier, subscriberName, serviceType);
 237                 results.addAll(resultsForSubscription);
 238             }
 239         }
 240
 241         return results;
 242     }
 243
 244     private ArrayList<ServiceInstanceSearchResult> getSearchResultsForSingleSubscription(ServiceSubscription serviceSubscription, String subscriberId, String instanceIdentifier, String subscriberName, String serviceType) {
 245         ArrayList<ServiceInstanceSearchResult> results = new ArrayList<>();
 246
 247         if (serviceSubscription.serviceInstances != null) {
 248             for (ServiceInstance serviceInstance : serviceSubscription.serviceInstances.serviceInstance) {
 249                 ServiceInstanceSearchResult serviceInstanceSearchResult =
 250                         new ServiceInstanceSearchResult(serviceInstance.serviceInstanceId, subscriberId, serviceType, serviceInstance.serviceInstanceName,
 251                                 subscriberName, serviceInstance.modelInvariantId, serviceInstance.modelVersionId, serviceSubscription.isPermitted);
 252
 253                 if (instanceIdentifier == null) {
 254                     results.add(serviceInstanceSearchResult);
 255                 } else if (serviceInstanceMatchesIdentifier(instanceIdentifier, serviceInstance)) {
 256                     results.add(serviceInstanceSearchResult);
 257                 }
 258             }
 259         }
 260
 261         return results;
 262     }
 263
 264     private boolean serviceInstanceMatchesIdentifier(String instanceIdentifier, ServiceInstance serviceInstance) {
 265         return instanceIdentifier.equals(serviceInstance.serviceInstanceId) || instanceIdentifier.equals(serviceInstance.serviceInstanceName);
 266     }
 267
 268     @Override
 269     public Response getVersionByInvariantId(List<String> modelInvariantId) {
 270         try {
 271             return aaiClient.getVersionByInvariantId(modelInvariantId);
 272         } catch (Exception e) {
 273             e.printStackTrace();
 274         }
 275         return null;
 276     }
 277
 278     @Override
 279     public AaiResponse<Pnf> getSpecificPnf(String pnfId) {
 280         return aaiClient.getSpecificPnf(pnfId);
 281     }
 282
 283     @Override
 284     public AaiResponse getPNFData(String globalCustomerId, String serviceType, String modelVersionId, String modelInvariantId, String cloudRegion, String equipVendor, String equipModel) {
 285         return aaiClient.getPNFData(globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion, equipVendor, equipModel);
 286     }
 287
 288
 289
 290     @Override
 291     public AaiResponse getServices(RoleValidator roleValidator) {
 292         AaiResponse<GetServicesAAIRespone> subscriberResponse = aaiClient.getServices();
 293         if (subscriberResponse.getT() != null)
 294             for (org.onap.vid.aai.model.AaiGetServicesRequestModel.Service service : subscriberResponse.getT().service) {
 295                 service.isPermitted = true;
 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         AaiResponse<AicZones> response = aaiClient.getAllAicZones();
 327         return response;
 328     }
 329
 330     @Override
 331     public AaiResponse getAicZoneForPnf(String globalCustomerId, String serviceType, String serviceId) {
 332         String aicZone = "";
 333
 334         AaiResponse<ServiceRelationships> serviceInstanceResp = aaiClient.getServiceInstance(globalCustomerId, serviceType, serviceId);
 335         if (serviceInstanceResp.getT() != null) {
 336             List<String> aicZoneList = getRelationshipDataByType(serviceInstanceResp.getT().getRelationshipList(), "zone", "zone.zone-id");
 337             if (aicZoneList.size() > 0) {
 338                 aicZone = aicZoneList.get(0);
 339             } else {
 340                 logger.warn("aic zone not found for service instance " + serviceId);
 341             }
 342         } else {
 343             if (serviceInstanceResp.getErrorMessage() != null) {
 344                 logger.error("get service instance " + serviceId + " return error", serviceInstanceResp.getErrorMessage());
 345                 return new AaiResponse(aicZone , serviceInstanceResp.getErrorMessage() ,serviceInstanceResp.getHttpCode());
 346             } else {
 347                 logger.warn("get service instance " + serviceId + " return empty body");
 348                 return new AaiResponse(aicZone , "get service instance " + serviceId + " return empty body" ,serviceInstanceResp.getHttpCode());
 349             }
 350         }
 351
 352         return new AaiResponse(aicZone , null ,HttpStatus.SC_OK);
 353     }
 354
 355     @Override
 356     public AaiResponse getNodeTemplateInstances(String globalCustomerId, String serviceType, String modelVersionId, String modelInvariantId, String cloudRegion) {
 357         return aaiClient.getNodeTemplateInstances(globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion);
 358     }
 359
 360     @Override
 361     public Collection<Service> getServicesByDistributionStatus() {
 362         AaiResponse<GetServiceModelsByDistributionStatusResponse> serviceModelsByDistributionStatusResponse = aaiClient.getServiceModelsByDistributionStatus();
 363         Collection<Service> services = new ArrayList<>();
 364         if (serviceModelsByDistributionStatusResponse.getT() != null) {
 365             List<Result> results = serviceModelsByDistributionStatusResponse.getT().getResults();
 366             for (Result result : results) {
 367                 if(result.getModel() != null) {
 368                     List<Service> service = convertModelToService(result.getModel());
 369                     if (service != null) {
 370                         services.addAll(service);
 371                     }
 372                 }
 373             }
 374         }
 375         return services;
 376     }
 377
 378     @Override
 379     public List<String> getServiceInstanceAssociatedPnfs(String globalCustomerId, String serviceType, String serviceInstanceId) {
 380         List<String> pnfs = new ArrayList<>();
 381
 382         AaiResponse<ServiceRelationships> serviceInstanceResp = aaiClient.getServiceInstance(globalCustomerId, serviceType, serviceInstanceId);
 383         if (serviceInstanceResp.getT() != null) {
 384             List<String> logicalLinks = getRelationshipDataByType(serviceInstanceResp.getT().getRelationshipList(), "logical-link", "logical-link.link-name");
 385             for (String logicalLink : logicalLinks) {
 386                 String link = "";
 387                 try {
 388                     link = URLEncoder.encode(logicalLink, "UTF-8");
 389                     AaiResponse<LogicalLinkResponse> logicalLinkResp = aaiClient.getLogicalLink(link);
 390                     if (logicalLinkResp.getT() != null) {
 391                         //lag-interface is the key for pnf - approved by Bracha
 392                         List<String> linkPnfs = getRelationshipDataByType(logicalLinkResp.getT().getRelationshipList(), "lag-interface", "pnf.pnf-name");
 393                         if (linkPnfs.size() > 0) {
 394                             pnfs.addAll(linkPnfs);
 395                         } else {
 396                             logger.warn("no pnf found for logical link " + logicalLink);
 397                         }
 398                     } else {
 399                         if (logicalLinkResp.getErrorMessage() != null) {
 400                             logger.error("get logical link " + logicalLink + " return error", logicalLinkResp.getErrorMessage());
 401                         } else {
 402                             logger.warn("get logical link " + logicalLink + " return empty body");
 403                         }
 404                     }
 405                 } catch (UnsupportedEncodingException e) {
 406                     logger.error("Failed to encode logical link: " + logicalLink, e.getMessage());
 407                 }
 408             }
 409         } else {
 410             if (serviceInstanceResp.getErrorMessage() != null) {
 411                 logger.error("get service instance " + serviceInstanceId + " return error", serviceInstanceResp.getErrorMessage());
 412             } else {
 413                 logger.warn("get service instance " + serviceInstanceId + " return empty body");
 414             }
 415         }
 416
 417         return pnfs.stream().distinct().collect(Collectors.toList());
 418     }
 419
 420     private List<String> getRelationshipDataByType(RelationshipList relationshipList, String relationshipType, String relationshipDataKey) {
 421         List<String> relationshipValues = new ArrayList<>();
 422         for (Relationship relationship : relationshipList.getRelationship()) {
 423             if (relationship.getRelatedTo().equals(relationshipType)) {
 424                 relationshipValues.addAll( relationship.getRelationDataList().stream()
 425                         .filter(rel -> rel.getRelationshipKey().equals(relationshipDataKey))
 426                         .map(RelationshipData::getRelationshipValue)
 427                         .collect(Collectors.toList())
 428                 );
 429             }
 430         }
 431
 432
 433         return relationshipValues;
 434     }
 435 }