server/src/main/java/org/onap/usecaseui/server/service/lcm/impl/SotnServiceTemplateServiceImpl.java

   1 /**
   2  * Copyright (C) 2020 Huawei, Inc. and others. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.onap.usecaseui.server.service.lcm.impl;
  18
  19
  20 import com.fasterxml.jackson.core.type.TypeReference;
  21 import com.fasterxml.jackson.databind.DeserializationFeature;
  22 import com.fasterxml.jackson.databind.ObjectMapper;
  23 import okhttp3.MediaType;
  24 import okhttp3.RequestBody;
  25 import okhttp3.ResponseBody;
  26 //import org.onap.usecaseui.server.bean.lcm.sotne2eservice.*;
  27 //import org.onap.usecaseui.server.bean.lcm.sotne2eservice.Connectivity;
  28 //import org.onap.usecaseui.server.bean.sotn.Pinterface;
  29 import org.onap.usecaseui.server.bean.orderservice.ServiceEstimationBean;
  30 import org.onap.usecaseui.server.service.lcm.SotnServiceTemplateService;
  31 import org.onap.usecaseui.server.service.lcm.domain.aai.AAIService;
  32 import org.onap.usecaseui.server.service.lcm.domain.aai.bean.Relationship;
  33 //import org.onap.usecaseui.server.service.lcm.domain.aai.bean.ServiceInstance;
  34 import org.onap.usecaseui.server.service.lcm.domain.so.bean.DeleteOperationRsp;
  35 import org.onap.usecaseui.server.service.lcm.domain.so.bean.ServiceOperation;
  36 import org.onap.usecaseui.server.service.lcm.domain.so.SOService;
  37 import org.onap.usecaseui.server.service.lcm.domain.so.bean.Operation;
  38 import org.onap.usecaseui.server.service.lcm.domain.so.exceptions.SOException;
  39 import org.onap.usecaseui.server.bean.lcm.sotne2eservice.*;
  40 import org.onap.usecaseui.server.bean.activateEdge.*;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43 import org.springframework.beans.factory.annotation.Autowired;
  44 import org.springframework.core.io.ClassPathResource;
  45 import org.springframework.core.io.Resource;
  46 import retrofit2.Response;
  47 import org.onap.usecaseui.server.service.lcm.domain.aai.bean.RelationshipData;
  48
  49 import javax.servlet.ServletInputStream;
  50 import javax.servlet.http.HttpServletRequest;
  51 import java.io.File;
  52 import java.io.FileReader;
  53 import java.io.IOException;
  54 import org.json.simple.parser.JSONParser;
  55 import org.json.simple.parser.ParseException;
  56
  57 import java.util.*;
  58 import java.util.stream.Collectors;
  59
  60 import org.springframework.context.annotation.EnableAspectJAutoProxy;
  61 import org.springframework.stereotype.Service;
  62
  63 @Service("SotnLcmService")
  64 @org.springframework.context.annotation.Configuration
  65 @EnableAspectJAutoProxy
  66 public class SotnServiceTemplateServiceImpl implements SotnServiceTemplateService {
  67
  68     private static final Logger logger = LoggerFactory.getLogger(SotnServiceTemplateServiceImpl.class);
  69
  70     private SOService soService;
  71     private AAIService aaiService;
  72
  73
  74
  75
  76     private Map<String, Model> readConfigToMap(ModelConfig modelConfig) {
  77
  78         //ModelConfig modelConfig = readFile();
  79 //        Map<String, Model> modelinfo = modelConfig.getResourcemodelinformation().stream()
  80 //                .collect(Collectors.toMap(ModelInfor::getModelType, ModelInfor::getModel));
  81         return null;
  82     }
  83
  84     public ModelConfig readFile() {
  85         ObjectMapper mapper = new ObjectMapper();
  86         try {
  87             Resource resource = new ClassPathResource("modelconfig.json");
  88             ModelConfig modelInformation = mapper.readValue(resource.getInputStream(), ModelConfig.class);
  89             logger.info("subscriber id is: {}.", modelInformation.getSubscriberId());
  90             return modelInformation;
  91         } catch (IOException ex) {
  92             logger.error("Exception occured while reading configuration file: {}", ex);
  93             return null;
  94         }
  95     }
  96     public ModelConfig readFile_unni(){
  97         ObjectMapper mapper = new ObjectMapper();
  98         try {
  99             Resource resource = new ClassPathResource("modelconfigunni.json");
 100             ModelConfig modelInformation = mapper.readValue(resource.getInputStream(), ModelConfig.class);
 101             logger.info("subscriber id is: {}.", modelInformation.getSubscriberId());
 102             return modelInformation;
 103         } catch (IOException ex) {
 104             logger.error("Exception occured while reading configuration file: {}", ex);
 105             return null;
 106         }
 107     }
 108
 109     public ServiceOperation instantiate_CCVPN_Service(HashMap<String, Object> reqt) {
 110         ServletInputStream inStream = null;
 111         E2EServiceInstanceRequest requestBody = null;
 112         Response<ServiceOperation> sotnserviceresponse = null;
 113         Operation sotnservice = null;
 114         ModelConfig modelConfig = readFile_unni();
 115         Model servicemodel = modelConfig.getServiceModel().getModel();
 116         //Map<String, Model> modelInfo = readConfigToMap(modelConfig);
 117         List<ModelInfor> resourceModel = modelConfig.getResourcemodelinformation();
 118
 119         String customerid = modelConfig.getSubscriberId();
 120         String subscriptionType = modelConfig.getSubscriptionType();
 121
 122         requestBody = create_CCVPN_Request_Body(reqt, resourceModel, customerid, subscriptionType, servicemodel);
 123         try {
 124             logger.info("SO request formed : " + new ObjectMapper().writeValueAsString(requestBody));
 125         } catch (IOException e) {
 126             logger.info("IOException : " + e.getMessage());
 127         }
 128
 129         ServiceOperation sotnserviceoperation = createSotnService(requestBody);
 130         sotnservice = sotnserviceoperation.getService();
 131         logger.info("Began to sleep for ");
 132         try {
 133             Thread.sleep(1);
 134         } catch (Exception e) {
 135             logger.info("sleep Interrupted");
 136         }
 137
 138         logger.info("wokeup to sleep ");
 139         return sotnserviceoperation;
 140     }
 141
 142     public ServiceOperation createSotnService(E2EServiceInstanceRequest requestBody) {
 143         Operation result = new Operation();
 144         try {
 145               logger.info("SO instantiate SOTN service is starting");
 146               Response<ServiceOperation> sotnserviceresponse = soService.instantiateSOTNService(requestBody).execute();
 147               logger.info("SO instantiate SOTN service has finished");
 148             if (sotnserviceresponse.isSuccessful()) {
 149                 logger.info("SO instantiate SOTN service is successful");
 150                 return sotnserviceresponse.body();
 151             } else {
 152                 logger.error(String.format("Can not instantiate SOTN service[code=%s, message=%s]", sotnserviceresponse.code(), sotnserviceresponse.message()));
 153                 throw new SOException("SO instantiate SOTN service failed!");
 154             }
 155         } catch (Exception e) {
 156             throw new SOException("SO Service is not available!", e);
 157         }
 158
 159     }
 160
 161     private E2EServiceInstanceRequest create_CCVPN_Request_Body(Map request, List<ModelInfor> resourceModel,
 162                                                                 String customerid, String subscriptionType, Model servicemodel  ) {
 163
 164         E2EServiceInstanceRequest e2eServiceInstanceRequest = new E2EServiceInstanceRequest();
 165         E2EService e2eService = new E2EService();
 166         E2EParameters parameters = new E2EParameters();
 167         e2eServiceInstanceRequest.setService(e2eService);
 168         e2eService.setName(request.get("name").toString());
 169         e2eService.setDescription(request.get("description").toString());
 170
 171         e2eService.setServiceInvariantUuid(servicemodel.getResourceInvariantUuid());         //Need to get from SDC or Configuration
 172         e2eService.setServiceUuid(servicemodel.getResourceUuid());
 173         e2eService.setGlobalSubscriberId(customerid);
 174         e2eService.setServiceType(subscriptionType);
 175         e2eService.setParameters(parameters);
 176
 177
 178         // modelInfo.forEach ((k,v) -
 179
 180         //        Iterator<Map.Entry<String, Model>> it = modelInfo.entrySet().iterator();
 181         //
 182         //        while (it.hasNext()) {
 183
 184         //List<Object> ResourceModelList = modelInfo.get("resourcemodelinformation");
 185         List<ResourceRequest> resourceList = new LinkedList<ResourceRequest>();
 186         ResourceRequest resource = null;
 187
 188         for (ModelInfor singleresourceModel : resourceModel) {
 189
 190
 191             resource = new ResourceRequest();
 192             resource.setResourceName(singleresourceModel.getModel().getResourceName());
 193             resource.setResourceInvariantUuid(singleresourceModel.getModel().getResourceInvariantUuid());
 194             resource.setResourceCustomizationUuid(singleresourceModel.getModel().getResourceCustomizationUuid());
 195             resource.setResourceUuid(singleresourceModel.getModel().getResourceInvariantUuid());
 196             resource.setParameters(new E2EParameters());
 197             System.out.println(resource);
 198
 199             resourceList.add(resource);
 200             System.out.println("listaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
 201             System.out.println(resourceList);
 202             e2eService.getParameters().setResources(resourceList);
 203
 204         }
 205         //List<ResourceRequest> resourceList = new LinkedList<ResourceRequest>()
 206
 207         //            System.out.println("listaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
 208         //            System.out.println(resourceList);
 209         //            e2eService.getParameters().setResources(resourceList);
 210
 211         //        List<ResourceRequest> resourceList = new LinkedList<ResourceRequest>();
 212         //        resourceList.add(resource);
 213         //        e2eService.getParameters().setResources(resourceList);
 214
 215         HashMap<String, Object> requestInputsmap = new HashMap();
 216         requestInputsmap.put("l2vpn", request.get("l2vpn"));
 217         requestInputsmap.put("sotnUni", request.get("sotnUni"));
 218         e2eService.getParameters().setRequestInputs(requestInputsmap);
 219         e2eServiceInstanceRequest.setService(e2eService);
 220         return e2eServiceInstanceRequest;
 221     }
 222
 223
 224     public ServiceInstance getServiceInstancesInfo(String customerId, String serviceType, String serviceInstanceId) throws Exception {
 225         logger.info("Fire getServiceInstances : Begin");
 226         ObjectMapper mapper = new ObjectMapper();
 227
 228         Response<ResponseBody> response = this.aaiService.getServiceInstancesForEdge(customerId, serviceType, serviceInstanceId).execute();
 229         if (response.isSuccessful()) {
 230             logger.info("Fire getServiceInstances : End");
 231             String result = new String(response.body().bytes());
 232             ServiceInstance serviceInstance = mapper.readValue(result, ServiceInstance.class);
 233             return serviceInstance;
 234         } else {
 235             logger.info("Fire getServiceInstances : Failed");
 236         }
 237         return null;
 238     }
 239
 240     private Connectivity getConnectivityInfo(String connectivityinstanceid) throws IOException {
 241         logger.info("Fire getServiceInstancesForEdge : Begin");
 242         ObjectMapper mapper = new ObjectMapper();
 243         Response<ResponseBody> response = this.aaiService.getConnectivityInformation(connectivityinstanceid).execute();
 244         if (response.isSuccessful()) {
 245             logger.info("Fire getServiceInstancesForEdge : End");
 246             String result = new String(response.body().bytes());
 247             Connectivity connectivity = mapper.readValue(result, Connectivity.class);
 248             return connectivity;
 249         } else {
 250            logger.info("Fire getServiceInstancesForEdge : Failed");
 251         }
 252         return null;
 253     }
 254
 255     public Pinterface getTerminationPoint(String pnfName, String tpId) throws Exception {
 256         logger.info("Fire getTerminationPoint : Begin");
 257         ObjectMapper mapper = new ObjectMapper();
 258         // Response<ResponseBody> response = this.aaiService.getPinterfaceByPnfName(pnfName,tpId).execute();
 259         Response<ResponseBody> response = this.aaiService.getTerminationPoint(pnfName, tpId).execute();
 260         if (response.isSuccessful()) {
 261             logger.info("Fire getTerminationPoint : End");
 262             String result = new String(response.body().bytes());
 263             Pinterface pinterface = mapper.readValue(result, Pinterface.class);
 264             return pinterface;
 265         } else {
 266             logger.info("Fire getTerminationPoint : Failed");
 267         }
 268         return null;
 269     }
 270     private AllottedResource getAllottedResource(String globalCustomerId, String serviceType, String siteserviceinstanceid, String allottedResourceId) throws IOException {
 271         logger.info("Fire getServiceInstancesForEdge : Begin");
 272         ObjectMapper mapper = new ObjectMapper();
 273         Response<ResponseBody> response = this.aaiService.getAllotedResourceFor5G(globalCustomerId, serviceType, siteserviceinstanceid, allottedResourceId).execute();
 274         if (response.isSuccessful()) {
 275             logger.info("Fire getServiceInstancesForEdge : End");
 276             String result = new String(response.body().bytes());
 277             AllottedResource allottedResource = mapper.readValue(result, AllottedResource.class);
 278             return allottedResource;
 279         } else {
 280             logger.info("Fire getServiceInstancesForEdge : Failed");
 281         }
 282         return null;
 283     }
 284
 285     private SiteResource getSiteResource(String siteResourceID) throws IOException {
 286         logger.info("Fire get site resource : Begin");
 287         ObjectMapper mapper = new ObjectMapper();
 288         Response<ResponseBody> response = this.aaiService.getSiteResourceInfo(siteResourceID).execute();
 289         if (response.isSuccessful()) {
 290             logger.info("Fire get site resource : End");
 291             String result = new String(response.body().bytes());
 292             SiteResource resource = mapper.readValue(result, SiteResource.class);
 293             return resource;
 294         } else {
 295             logger.info("Fire get site resource : Failed");
 296         }
 297
 298         return null;
 299     }
 300
 301     private ComplexObj getComplexData(String complexID) throws IOException {
 302         logger.info("Fire get complex Object : Begin");
 303         ObjectMapper mapper = new ObjectMapper();
 304         Response<ResponseBody> response = this.aaiService.getComplexObject(complexID).execute();
 305         if (response.isSuccessful()) {
 306             logger.info("Fire get complex Object : End");
 307             String result = new String(response.body().bytes());
 308             ComplexObj complexObj = mapper.readValue(result, ComplexObj.class);
 309             return complexObj;
 310         } else {
 311            logger.info("Fire get complex Object : Failed");
 312         }
 313         return null;
 314     }
 315
 316
 317     public String getSOTNSiteInformationTopology(String subscriptionType, String instanceid) {
 318
 319         ModelConfig modelConfig = readFile();
 320         Map<String, Model> modelInfo = readConfigToMap(modelConfig);
 321         String customerId = modelConfig.getSubscriberId();
 322
 323         ServiceInstance serviceInstance = null;
 324         ServiceInstance siteservice = null;
 325         Map<String, Object> connectivityparams;
 326         List<String> vpnparams = new ArrayList<String>(Arrays.asList("cir", "eir", "cbs", "ebs", "colorAware", "couplingFlag", "ethtSvcName"));
 327         List<Map<String, Object>> sites = new LinkedList<Map<String, Object>>();
 328         String jsonresponse = "";
 329         String pnfname = "";
 330         String allottedpinterfaceid = "";
 331         String linkstatus = "";
 332         AllottedResource allottedResource = new AllottedResource();
 333
 334         //----------------------------- GET SERVICE INSTANCE INFORMATION FROM AAI : BEGIN ---------------------------------------
 335         try {
 336             serviceInstance = getServiceInstancesInfo(customerId, subscriptionType, instanceid);
 337             if (serviceInstance == null)
 338                 return null;
 339         } catch (Exception e) {
 340             logger.info("Query Service Instance information failed. No service information found for customer "
 341                     + customerId + " and Service Type " + subscriptionType);
 342             return null;
 343         }
 344
 345         List<Relationship> relationship = serviceInstance.getRelationshipList().getRelationship().stream().filter(relation -> relation.getRelatedTo()
 346                 .equalsIgnoreCase("allotted-resource")).collect(Collectors.toList());
 347         if (relationship.size() > 0 && relationship != null) {
 348             // This is SOTN service
 349             connectivityparams = new HashMap<String, Object>();
 350             relationship = serviceInstance.getRelationshipList().getRelationship();
 351             Relationship relation = relationship.stream()
 352                     .filter(relate -> "connectivity".equalsIgnoreCase(relate.getRelatedTo()))
 353                     .findAny()
 354                     .orElse(null);
 355             try {
 356                 String connectivityinstanceid = relation.getRelatedLink().substring(relation.getRelatedLink().lastIndexOf("/") + 1);
 357                 Connectivity connectivity = getConnectivityInfo(connectivityinstanceid);
 358                 connectivityparams = new ObjectMapper().readValue(connectivity.toString(), HashMap.class);
 359             } catch (IOException e) {
 360                 logger.info("IO Exception occured " + e.getMessage());
 361             }
 362             //nodeId-10.10.10.10-ltpId-147
 363             allottedpinterfaceid = "nodeId-" + connectivityparams.get("accessNodeId").toString() + "-ltpId-" + connectivityparams.get("accessLtpId").toString();
 364             pnfname = connectivityparams.get("accessNodeId").toString();
 365             try {
 366                 Pinterface pinterface = getTerminationPoint(pnfname, allottedpinterfaceid);
 367                 linkstatus = pinterface.getOperationalStatus();
 368                 if (linkstatus.equalsIgnoreCase("overloaded"))
 369                     linkstatus = "up";
 370             } catch (Exception e) {
 371                 logger.info("Exception: "+ e.getMessage());
 372             }
 373
 374             List<Relationship> servicerelationList = relationship.stream()
 375                     .filter(relate -> "service-instance".equalsIgnoreCase(relate.getRelatedTo())).collect(Collectors.toList());
 376             for (Relationship servicerelation : servicerelationList) {
 377                 String siteserviceinstanceid = servicerelation.getRelatedLink().substring(servicerelation.getRelatedLink().lastIndexOf("/") + 1);
 378                 String cvlan = "";
 379                 String externalltp = "";
 380                 Map<String, Object> site;
 381                 try {
 382                     siteservice = getServiceInstancesInfo(customerId, subscriptionType, siteserviceinstanceid);
 383                     if (siteservice == null)
 384                         return null;
 385                 } catch (Exception e) {
 386                     logger.info("Query Service Instance information failed. No service information found for customer "
 387                             + customerId + " and Service Type " + subscriptionType);
 388                     return null;
 389                 }
 390                 List<Relationship> ssrelationship = siteservice.getRelationshipList().getRelationship().stream()
 391                         .filter(siterelation -> siterelation.getRelatedTo().equalsIgnoreCase("site-resource") ||
 392                                 siterelation.getRelatedTo().equalsIgnoreCase("allotted-resource")).collect(Collectors.toList());
 393
 394                 if (ssrelationship.size() > 0) {
 395                     Relationship allotrel = ssrelationship.stream()
 396                             .filter(relate -> "allotted-resource".equalsIgnoreCase(relate.getRelatedTo()))
 397                             .findAny()
 398                             .orElse(null);
 399                     String allottedResourceId = allotrel.getRelatedLink().substring(allotrel.getRelatedLink().lastIndexOf("/") + 1);
 400                     try {
 401                         allottedResource = getAllottedResource(customerId, subscriptionType, siteserviceinstanceid, allottedResourceId);
 402                         cvlan = allottedResource.getCvlan();
 403                         externalltp = allottedResource.getAccessLtpId();
 404
 405                     } catch (Exception e) {
 406                         logger.info("Query Allotted resource for site service" + siteserviceinstanceid + " allotted resource Id " + allottedResourceId);
 407                     }
 408
 409
 410                     Relationship siterel = ssrelationship.stream()
 411                             .filter(relate -> "site-resource".equalsIgnoreCase(relate.getRelatedTo()))
 412                             .findAny()
 413                             .orElse(null);
 414                     String siteResourceID = siterel.getRelatedLink().substring(siterel.getRelatedLink().lastIndexOf("/") + 1);
 415                     try {
 416                         SiteResource resource = getSiteResource(siteResourceID);
 417                         site = new HashMap<String, Object>();
 418                         site.put("siteId", resource.getSiteResourceId());
 419                         site.put("siteName", resource.getSiteResourceName());
 420                         site.put("description", resource.getDescription());
 421                         site.put("role", "dsvpn-hub");
 422                         List<Relationship> complexRelationship = resource.getRelationshipList().getRelationship()
 423                                 .stream().filter(rel -> rel.getRelatedTo().equalsIgnoreCase("complex"))
 424                                 .collect(Collectors.toList());
 425                         for (Relationship complexrelation : complexRelationship) {
 426                             String complexID = complexrelation.getRelatedLink().substring(complexrelation.getRelatedLink().lastIndexOf("/") + 1);
 427                             ComplexObj complex = getComplexData(complexID);    //getSiteResourceInfo
 428                             site.put("address", complex.getCity());
 429                             site.put("location", complex.getCity());
 430                             site.put("zipCode", complex.getPostalCode());
 431                         }
 432                         Map<String, Object> attr = new HashMap<String, Object>();
 433                         attr.put("cvlan", cvlan);
 434                         attr.put("Access node Id", connectivityparams.get("accessNodeId").toString());
 435                         attr.put("Access LTP Id", externalltp);
 436                         attr.put("Location", site.get("location"));
 437                         attr.put("Site Name", site.get("siteName"));
 438                         attr.put("Zip Code", site.get("zipCode"));
 439                         attr.put("Link Status", linkstatus);
 440                         attr.put("Inter-Domain LTP Id", connectivityparams.get("accessLtpId").toString());
 441                         site.put("attribute", attr);
 442                         sites.add(site);
 443                     } catch (Exception e) {
 444                         logger.info("Query Service Instance information failed. No service information found for customer "
 445                                 + customerId + " and Service Type " + subscriptionType);
 446                         return null;
 447                     }
 448                 } else {
 449                     String requestinput = siteservice.getInputparameters();
 450                     E2EServiceInstanceRequest e2eserviceRequest = new E2EServiceInstanceRequest();
 451                     ObjectMapper mapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 452                     try {
 453                         e2eserviceRequest = mapper.readValue(requestinput.toString(), new TypeReference<E2EServiceInstanceRequest>() {
 454                         });
 455                     } catch (IOException e) {
 456                         logger.info("IOException: "+ e.getMessage());
 457                     }
 458
 459                     HashMap<String, ?> requestInputs = e2eserviceRequest.getService().getParameters().getRequestInputs();
 460                     site = new HashMap<String, Object>();
 461                     Map<String, Object> attr = new HashMap<String, Object>();
 462                     for (Map.Entry<String, ?> e : requestInputs.entrySet()) {
 463                         if (e.getKey().contains("name")) {
 464                             site.put("siteName", (String) requestInputs.get(e.getKey()));
 465
 466                         } else if (e.getKey().contains("description")) {
 467                             site.put("description", (String) requestInputs.get(e.getKey()));
 468
 469                         } else if (e.getKey().contains("role")) {
 470                             site.put("role", (String) requestInputs.get(e.getKey()));
 471
 472                         } else if (e.getKey().contains("address")) {
 473                             site.put("location", (String) requestInputs.get(e.getKey()));
 474
 475                         } else if (e.getKey().contains("postcode")) {
 476                             site.put("zipCode", (String) requestInputs.get(e.getKey()));
 477
 478                         } else if (e.getKey().contains("cVLAN")) {
 479                             attr.put("cvlan", (String) requestInputs.get(e.getKey()));
 480
 481                         }
 482                     }
 483                     attr.put("Location", site.get("location"));
 484                     attr.put("Site Name", site.get("siteName"));
 485                     attr.put("Zip Code", site.get("zipCode"));
 486                     attr.put("Link Status", linkstatus);
 487                     site.put("attribute", attr);
 488                     sites.add(site);
 489                 }
 490             }
 491             try {
 492                 jsonresponse = new ObjectMapper().writeValueAsString(sites);
 493                 System.out.println(jsonresponse);
 494             } catch (IOException e) {
 495                 logger.info("IOException: "+ e.getMessage());
 496             }
 497
 498         }
 499         //----------------------------- GET SERVICE INSTANCE INFORMATION FROM AAI : END -----------------------------------------
 500         return jsonresponse;
 501     }
 502
 503     public DeleteOperationRsp deleteService(String serviceId, String subscriptionType) {
 504         ModelConfig modelConfig = readFile();
 505         Map<String, Model> modelInfo = readConfigToMap(modelConfig);
 506         String customerId = modelConfig.getSubscriberId();
 507         E2EServiceDelete deleteRequest = new E2EServiceDelete();
 508         deleteRequest.setServiceType(subscriptionType);
 509         deleteRequest.setGlobalSubscriberId(customerId);
 510         String requestStr = deleteRequest.toString();
 511         Integer sleeptime = Integer.parseInt(modelConfig.getDeleteSleepTime());
 512         //Get the service information from AAI - Begin
 513         ServiceInstance serviceInstance = new ServiceInstance();
 514         try {
 515             serviceInstance = getServiceInstancesInfo(customerId, subscriptionType, serviceId);
 516             if (serviceInstance == null) {
 517                 logger.info("Query Service Instance information failed. No service information found for customer "
 518                         + customerId + " and Service Type " + subscriptionType);
 519                 return null;
 520             }
 521
 522         } catch (Exception e) {
 523             logger.info("Query Service Instance information failed. No service information found for customer "
 524                     + customerId + " and Service Type " + subscriptionType);
 525             return null;
 526         }
 527
 528         List<Relationship> ssrelationship = serviceInstance.getRelationshipList().getRelationship().stream()
 529                 .filter(siterelation -> siterelation.getRelatedTo().equalsIgnoreCase("service-instance"))
 530                 .collect(Collectors.toList());
 531
 532         //Get the service information from AAI - Begin
 533         for (Relationship siterelation : ssrelationship) {
 534
 535             String siteserviceId = siterelation.getRelatedLink().substring(siterelation.getRelatedLink().lastIndexOf("/") + 1);
 536             try {
 537                 logger.info("so begin terminate site service " + siteserviceId);
 538                 RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), requestStr);
 539                 Response<DeleteOperationRsp> response = soService.terminateService(siteserviceId, requestBody).execute();
 540                 logger.info("so terminate has finished");
 541                 if (response.isSuccessful()) {
 542                     logger.info("so terminated site service " + siteserviceId + "successfully...");
 543
 544                 } else {
 545                     logger.error(String.format("Can not terminate service " + siteserviceId + " [code=%s, message=%s]", response.code(), response.message()));
 546                     throw new SOException("SO terminate service failed!");
 547                 }
 548             } catch (IOException e) {
 549                 throw new SOException("SO Service is not available!", e);
 550             }
 551         }
 552         try {
 553             logger.info("Began to sleep for " + sleeptime);
 554             Thread.sleep(sleeptime);
 555         } catch (InterruptedException e) {
 556             logger.error(String.format("Thread Interruppted from sleep while deleting service subscription"));
 557         }
 558         try {
 559             logger.info("so begin terminate Connectivity service " + serviceId);
 560             RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), requestStr);
 561             Response<DeleteOperationRsp> response = soService.terminateService(serviceId, requestBody).execute();
 562             logger.info("so terminate has finished");
 563             if (response.isSuccessful()) {
 564                 logger.info("so terminated connectivity service " + serviceId + "successfully...");
 565
 566             } else {
 567                 logger.error(String.format("Can not terminate service " + serviceId + " [code=%s, message=%s]", response.code(), response.message()));
 568                 throw new SOException("SO terminate service failed!");
 569             }
 570             return response.body();
 571         } catch (IOException e) {
 572             throw new SOException("SO Service is not available!", e);
 573         }
 574     }
 575
 576     public VpnBinding getSOTNPinterfaceByVpnId(String vpnId) throws Exception {
 577
 578         logger.info("Fire getSOTNPinterfaceByVpnId : Begin");
 579         ObjectMapper mapper = new ObjectMapper();
 580         Response<ResponseBody> response = this.aaiService.getPinterfaceByVpnId(vpnId).execute();
 581
 582         //Response<ResponseBody> response = this.aaiService.getSOTNPinterfaceByVpnId(vpnId).execute();
 583         if (response.isSuccessful()) {
 584             logger.info("Fire getSOTNPinterfaceByVpnId : End");
 585             String result = new String(response.body().bytes());
 586             VpnBinding vpnBinding = mapper.readValue(result, VpnBinding.class);
 587             return vpnBinding;
 588         } else {
 589            logger.info("Fire getSOTNPinterfaceByVpnId : Failed");
 590         }
 591         return null;
 592     }
 593
 594
 595     public Pnf getSOTNPnf(String pnfname) throws Exception {
 596         logger.info("Fire getSOTNPnf : Begin");
 597         ObjectMapper mapper = new ObjectMapper();
 598         Response<ResponseBody> response = this.aaiService.getPnfInfo(pnfname).execute();
 599         if (response.isSuccessful()) {
 600             logger.info("Fire getSOTNPnf : End");
 601             String result = new String(response.body().bytes());
 602             Pnf pnf = mapper.readValue(result, Pnf.class);
 603             return pnf;
 604         } else {
 605            logger.info("Fire get SOTN PnF by Name : Failed" + pnfname);
 606         }
 607         return null;
 608     }
 609
 610     public LogicalLink getSOTNLinkbyName(String linkName) throws Exception {
 611         logger.info("Fire getSOTNLinkbyName : Begin");
 612         ObjectMapper mapper = new ObjectMapper();
 613         Response<ResponseBody> response = this.aaiService.getSpecificLogicalLink(linkName).execute();
 614         if (response.isSuccessful()) {
 615             logger.info("Fire getSOTNLinkbyName : End");
 616             String result = new String(response.body().bytes());
 617             LogicalLink logicalLink = mapper.readValue(result, LogicalLink.class);
 618             return logicalLink;
 619         } else {
 620            logger.info("Fire getSOTNLinkbyName : Failed");
 621         }
 622         return null;
 623     }
 624
 625     public Uni getUNIInfo(String uniId) throws Exception {
 626         logger.info("Fire getUNIInfo : Begin");
 627         ObjectMapper mapper = new ObjectMapper();
 628         Response<ResponseBody> response = this.aaiService.getUNIInfo(uniId).execute();
 629         if (response.isSuccessful()) {
 630             logger.info("Fire getUNIInfo : Begin");
 631             String result = new String(response.body().bytes());
 632             Uni uni = mapper.readValue(result, Uni.class);
 633             return uni;
 634         } else {
 635            logger.info("Fire getUNIInfo : Failed");
 636         }
 637         return null;
 638     }
 639
 640     public Vnfs getVnfs(String vnfId) throws Exception {
 641         logger.info("Fire getVnfs : Begin");
 642         ObjectMapper mapper = new ObjectMapper();
 643         Response<ResponseBody> response = this.aaiService.getVNFsDetail(vnfId).execute();
 644         if (response.isSuccessful()) {
 645             logger.info("Fire getVnfs : End");
 646             String result = new String(response.body().bytes());
 647             Vnfs vnf = mapper.readValue(result, Vnfs.class);
 648             return vnf;
 649         } else {
 650             logger.info("Fire getVnfs : Failed");
 651         }
 652         return null;
 653     }
 654
 655     public Node getNode(String id, String label, String image) {
 656         Node node = new Node();
 657         node.setId(id);
 658         node.setShape("circularImage");
 659         node.setImage("./assets/images/"+image);
 660         node.setLabel(label);
 661         node.setColor("Green");
 662         return node;
 663     }
 664
 665     public Edge getEdge(String fromId, String toId) {
 666         Edge edge = new Edge();
 667         edge.setFrom(fromId);
 668         edge.setTo(toId);
 669         return edge;
 670     }
 671
 672     @Override
 673     public String getVPNBindingInformationTopology(String subscriptionType, String instanceid, String vpnId) throws Exception {
 674
 675         List<Node> nodes = new ArrayList<Node>();
 676         List<Edge> edges = new ArrayList<Edge>();
 677         List<String> vpnparams = new ArrayList<String>(Arrays.asList("cir", "eir", "cbs", "ebs", "colorAware", "couplingFlag", "ethtSvcName"));
 678         String jsonresponse = "";
 679         Node connode = new Node();
 680         try {
 681             //---------------------------------Query VPN : Begin------------------------------
 682             VpnBinding vpnBinding = getSOTNPinterfaceByVpnId(vpnId);
 683             VpnInformation vpnInformation = vpnBinding.getVpnBinding().get(0);
 684             Node vpn = getNode(vpnInformation.getVpnId(), "VPN Binding", "vpnbinding.png");
 685             ObjectMapper mapper = new ObjectMapper();
 686             Map<String, Object> props = mapper.convertValue(vpnInformation, Map.class);
 687             props.remove("relationship-list");
 688             props.remove("resource-version");
 689             props.remove("vpn-region");
 690             props.remove("vpn-id");
 691             vpn.setDataNode(new ObjectMapper().writeValueAsString(props));
 692             nodes.add(vpn);
 693             //Query VPN : End
 694
 695             //Query P Interfaces
 696             List<Relationship> vpnpinterfacerelation = vpnInformation.getRelationshipList().getRelationship().stream()
 697                     .filter(relate -> "p-interface".equalsIgnoreCase(relate.getRelatedTo())).collect(Collectors.toList());
 698             for (Relationship temprel : vpnpinterfacerelation) {
 699                 String pinterfaceid = temprel.getRelatedLink().substring(temprel.getRelatedLink().lastIndexOf("/") + 1);
 700                 String parentaccessnode = "";
 701
 702                 RelationshipData[] pnfrelatedprop = temprel.getRelationshipData();
 703                 for (RelationshipData temp : pnfrelatedprop) {
 704                     if ("pnf.pnf-name".equalsIgnoreCase(temp.getRelationshipKey())) {
 705                         parentaccessnode = temp.getRelationshipValue();
 706                         break;
 707                     }
 708                 }
 709                 Pinterface pinterface = new Pinterface();
 710                 pinterface = getTerminationPoint(parentaccessnode, pinterfaceid);
 711                 Node vpnpinterface = getNode(pinterface.getInterfaceName(), "P-interface", "tpoint.png");
 712                 ObjectMapper vpnpintmapper = new ObjectMapper();
 713                 Map<String, Object> vpnpintprops = vpnpintmapper.convertValue(pinterface, Map.class);
 714                 vpnpintprops.remove("relationship-list");
 715                 vpnpintprops.remove("resource-version");
 716                 vpnpintprops.remove("in-maint");
 717                 vpnpinterface.setDataNode(new ObjectMapper().writeValueAsString(vpnpintprops));
 718                 nodes.add(vpnpinterface);
 719                 edges.add(getEdge(vpn.getId(),vpnpinterface.getId()));
 720             }
 721         } catch (Exception ex) {
 722             logger.info("Exception: "+ ex);
 723         }
 724         ResourceResponse resourceResponse = new ResourceResponse();
 725         resourceResponse.setNodes(nodes);
 726         resourceResponse.setEdges(edges);
 727         System.out.println(jsonresponse);
 728         return resourceResponse.toString();
 729     }
 730
 731     @Override
 732     public String getServiceInformationTopology(String subscriptionType, String instanceid) throws Exception {
 733
 734         List<Node> nodes = new ArrayList<Node>();
 735         List<Edge> edges = new ArrayList<Edge>();
 736         ServiceInstance serviceInstance = null;
 737         Connectivity connectivity = new Connectivity();
 738         Node connode = new Node();
 739
 740         //----------------------------- GET SERVICE INSTANCE INFORMATION FROM AAI : BEGIN ---------------------------------------
 741         try {
 742             ModelConfig modelConfig = readFile();
 743             String customerId = modelConfig.getSubscriberId();
 744
 745             serviceInstance = getServiceInstancesInfo(customerId, subscriptionType, instanceid);
 746             if (serviceInstance == null) {
 747                 return null;
 748             }
 749             else {
 750                 ObjectMapper serviceMapper = new ObjectMapper();
 751                 Map<String, Object> serviceProps = serviceMapper.convertValue(serviceInstance, Map.class);
 752                 serviceProps.remove("relationship-list");
 753                 serviceProps.remove("input-parameters");
 754                 serviceProps.remove("resource-version");
 755                 Node serviceNode = getNode(serviceInstance.getServiceInstanceId(), "Service", "service.png");
 756                 serviceNode.setDataNode(new ObjectMapper().writeValueAsString(serviceProps));
 757                 nodes.add(serviceNode);
 758             }
 759         } catch (Exception e) {
 760             logger.info("Exception: "+ e);
 761             return null;
 762         }
 763         //----------------------------- GET SERVICE INSTANCE INFORMATION FROM AAI : END ---------------------------------------
 764
 765         //-------------------------------GET GENERIC VNFS : BEGIN ----------------------------------------
 766
 767         List<Relationship> relationship = serviceInstance.getRelationshipList().getRelationship().stream().filter(relation -> relation.getRelatedTo()
 768                 .equalsIgnoreCase("generic-vnf")).collect(Collectors.toList());
 769         if (relationship.size() > 0 && relationship != null) {
 770             relationship = serviceInstance.getRelationshipList().getRelationship();
 771             String relatedLinkID = relationship.get(0).getRelatedLink();
 772             Vnfs vnf = getVnfs(relatedLinkID.substring(relatedLinkID.lastIndexOf("/") + 1));
 773             relationship = vnf.getRelationshipList().getRelationship();
 774
 775             ObjectMapper serviceMapper = new ObjectMapper();
 776             Map<String, Object> vnfProps = serviceMapper.convertValue(vnf, Map.class);
 777             vnfProps.remove("relationship-list");
 778             vnfProps.remove("in-maint");
 779             vnfProps.remove("resource-version");
 780             Node vnfNode = getNode(vnf.getVnfInstanceId(), "Vnf", "VNF.png");
 781             vnfNode.setDataNode(new ObjectMapper().writeValueAsString(vnfProps));
 782             nodes.add(vnfNode);
 783             edges.add(getEdge(serviceInstance.getServiceInstanceId(),vnf.getVnfInstanceId()));
 784
 785             Relationship relation = relationship.stream()
 786                     .filter(relate -> "connectivity".equalsIgnoreCase(relate.getRelatedTo()))
 787                     .findAny()
 788                     .orElse(null);
 789             try {
 790                 String connectivityinstanceid = relation.getRelatedLink().substring(relation.getRelatedLink().lastIndexOf("/") + 1);
 791                 connectivity = getConnectivityInfo(connectivityinstanceid);
 792                 Map<String, Object> connectivityparams = new ObjectMapper().readValue(connectivity.toString(), HashMap.class);
 793                 connode = getNode(connectivityparams.get("connectivityId").toString(), "Connectivity", "connectivity.png");
 794                 ObjectMapper conMapper = new ObjectMapper();
 795                 Map<String, Object> conprops = conMapper.convertValue(connectivity, Map.class);
 796                 conprops.remove("relationship-list");
 797                 conprops.remove("resource-version");
 798                 connode.setDataNode(new ObjectMapper().writeValueAsString(conprops));
 799                 nodes.add(connode);
 800                 edges.add(getEdge(vnf.getVnfInstanceId(), connectivityparams.get("connectivityId").toString()));
 801             } catch (IOException e) {
 802                 logger.info("IO Exception occured " + e.getMessage());
 803             }
 804
 805             //Query Connectivity : End
 806             List<Relationship> relationship1 = vnf.getRelationshipList().getRelationship().stream().filter(relation1 -> relation1.getRelatedTo()
 807                     .equalsIgnoreCase("uni")).collect(Collectors.toList());
 808             if (relationship1.size() > 0 && relationship1 != null) {
 809                 for (Relationship rel : relationship1) {
 810                     try {
 811                         String uniLink = rel.getRelatedLink();
 812                         String uniId = uniLink.substring(uniLink.lastIndexOf("/")+1);
 813                         Uni uniInfo = getUNIInfo(uniId);
 814                         Node uuinode = getNode(uniInfo.getId(), uniInfo.getId(), "edge.png");
 815                         ObjectMapper uuiMapper = new ObjectMapper();
 816                         Map<String, Object> uuiprops = uuiMapper.convertValue(uniInfo, Map.class);
 817                         uuiprops.remove("relationship-list");
 818                         uuiprops.remove("resource-version");
 819                         uuinode.setDataNode(new ObjectMapper().writeValueAsString(uuiprops));
 820                         nodes.add(uuinode);
 821                         edges.add(getEdge(vnf.getVnfInstanceId(), uniInfo.getId()));
 822
 823                         List<Relationship> unipinterfaceralation = uniInfo.getRelationshipList().getRelationship().stream()
 824                                 .filter(relate -> "p-interface".equalsIgnoreCase(relate.getRelatedTo())).collect(Collectors.toList());
 825                         for (Relationship temprel : unipinterfaceralation) {
 826                             String pinterfaceid = temprel.getRelatedLink().substring(temprel.getRelatedLink().lastIndexOf("/") + 1);
 827                             String parentaccessnode = "";
 828
 829                             RelationshipData[] pnfrelatedprop = temprel.getRelationshipData();
 830                             for (RelationshipData temp : pnfrelatedprop) {
 831                                 if ("pnf.pnf-name".equalsIgnoreCase(temp.getRelationshipKey())) {
 832                                     parentaccessnode = temp.getRelationshipValue();
 833                                     break;
 834                                 }
 835                             }
 836                             try {
 837
 838                                 Pinterface pinterface = getTerminationPoint(parentaccessnode, pinterfaceid);
 839
 840                                 ObjectMapper unipintmapper = new ObjectMapper();
 841                                 Map<String, Object> unipintprops = unipintmapper.convertValue(pinterface, Map.class);
 842                                 unipintprops.remove("relationship-list");
 843                                 unipintprops.remove("resource-version");
 844                                 unipintprops.remove("in-maint");
 845
 846                                 Node unipinterface = getNode(pinterface.getInterfaceName(), "P-interface", "tpoint.png");
 847                                 unipinterface.setDataNode(new ObjectMapper().writeValueAsString(unipintprops));
 848                                 nodes.add(unipinterface);
 849                                 edges.add(getEdge(uniInfo.getId(), unipinterface.getId()));
 850
 851                             } catch (Exception e) {
 852                                 logger.info("Exception:"+e.getMessage());
 853                             }
 854                         }
 855
 856                     } catch (IOException e) {
 857                         logger.info("IO Exception occured " + e.getMessage());
 858                     }
 859                 }
 860                 //Query UNI : End
 861             }
 862
 863             //---------------------------------Query VPN : Begin------------------------------
 864             Relationship vpnrelation = connectivity.getRelationshipList().getRelationship().stream()
 865                     .filter(relate -> "vpn-binding".equalsIgnoreCase(relate.getRelatedTo()))
 866                     .findAny()
 867                     .orElse(null);
 868             String vpnid = vpnrelation.getRelatedLink().substring(vpnrelation.getRelatedLink().lastIndexOf("/") + 1);
 869             VpnBinding vpnBinding = new VpnBinding();
 870             VpnInformation vpnInformation = new VpnInformation();
 871             try {
 872                 vpnBinding = getSOTNPinterfaceByVpnId(vpnid);
 873                 vpnInformation = vpnBinding.getVpnBinding().get(0);
 874             } catch (Exception e) {
 875                 logger.info("Exception:"+e.getMessage());
 876             }
 877
 878             ObjectMapper mapper = new ObjectMapper();
 879             Map<String, Object> props = mapper.convertValue(vpnInformation, Map.class);
 880             props.remove("relationship-list");
 881             props.remove("resource-version");
 882             props.remove("vpn-region");
 883             props.remove("vpn-id");
 884             Node vpn = getNode(vpnInformation.getVpnId(), "VPN Binding", "vpnbinding.png");
 885             vpn.setDataNode(new ObjectMapper().writeValueAsString(props));
 886             nodes.add(vpn);
 887             edges.add(getEdge(connode.getId(), vpn.getId()));
 888             //Query VPN : End
 889
 890             //Query P Interfaces
 891             List<Relationship> vpnpinterfacerelation = vpnInformation.getRelationshipList().getRelationship().stream()
 892                     .filter(relate -> "p-interface".equalsIgnoreCase(relate.getRelatedTo())).collect(Collectors.toList());
 893             for (Relationship temprel : vpnpinterfacerelation) {
 894                 String pinterfaceid = temprel.getRelatedLink().substring(temprel.getRelatedLink().lastIndexOf("/") + 1);
 895                 String parentaccessnode = "";
 896
 897                 RelationshipData[] pnfrelatedprop = temprel.getRelationshipData();
 898                 for (RelationshipData temp : pnfrelatedprop) {
 899                     if ("pnf.pnf-name".equalsIgnoreCase(temp.getRelationshipKey())) {
 900                         parentaccessnode = temp.getRelationshipValue();
 901                         break;
 902                     }
 903                 }
 904                 try {
 905                     Pinterface pinterface = getTerminationPoint(parentaccessnode, pinterfaceid);
 906                     edges.add(getEdge(vpn.getId(), pinterface.getInterfaceName()));
 907                 } catch (Exception e) {
 908                     logger.info("Exception:"+e.getMessage());
 909                 }
 910             }
 911         }
 912         ResourceResponse resourceResponse = new ResourceResponse();
 913         resourceResponse.setNodes(nodes);
 914         resourceResponse.setEdges(edges);
 915         logger.info("Service Topology:"+resourceResponse.toString());
 916         return resourceResponse.toString();
 917     }
 918
 919     @Override
 920     public String getSOTNResourceInformationTopology(String subscriptionType, String instanceid) throws Exception {
 921
 922         //--------------------------------------------------------------------------------------------------------------------------
 923         ModelConfig modelConfig = readFile();
 924         Map<String, Model> modelInfo = readConfigToMap(modelConfig);
 925         String customerId = modelConfig.getSubscriberId();
 926         ResourceResponse resourceResponse = new ResourceResponse();
 927         List<Node> nodes = new ArrayList<Node>();
 928         List<Edge> edges = new ArrayList<Edge>();
 929         List<String> vpnparams = new ArrayList<String>(Arrays.asList("cir", "eir", "cbs", "ebs", "colorAware", "couplingFlag", "ethtSvcName"));
 930         List<String> tpparams = new ArrayList<String>(Arrays.asList("ethtSvcName", "accessProviderId", "accessClientId", "accessTopologyId", "accessNodeId", "accessLtpId"));
 931         ServiceInstance serviceInstance = null;
 932         ServiceInstance siteservice = null;
 933         Map<String, Object> connectivityparams;
 934         String jsonresponse = "";
 935         AllottedResource allottedResource = new AllottedResource();
 936         Connectivity connectivity = new Connectivity();
 937         Node allottednode = new Node();
 938         Node connode = new Node();
 939
 940         String allottedpinterfaceid = "";
 941         ObjectMapper jsonmapper = new ObjectMapper();
 942         List<Relationship> tpinterface = new ArrayList<>();
 943         LogicalLink logicallink = new LogicalLink();
 944         Pnf extpnf = new Pnf();
 945         String logicallinkparentid = "";
 946         boolean ext_tp_found = false;
 947         //----------------------------- GET SERVICE INSTANCE INFORMATION FROM AAI : BEGIN ---------------------------------------
 948         try {
 949             serviceInstance = getServiceInstancesInfo(customerId, subscriptionType, instanceid);
 950             if (serviceInstance == null)
 951                 return null;
 952         } catch (Exception e) {
 953             logger.info("Query Service Instance information failed. No service information found for customer "
 954                     + customerId + " and Service Type " + subscriptionType);
 955             return null;
 956         }
 957
 958
 959         List<Relationship> relationship = serviceInstance.getRelationshipList().getRelationship().stream().filter(relation -> relation.getRelatedTo()
 960                 .equalsIgnoreCase("allotted-resource")).collect(Collectors.toList());
 961         if (relationship.size() > 0 && relationship != null) {
 962             // This is SOTN service
 963             //Query Connectivity : Begin
 964             connectivityparams = new HashMap<String, Object>();
 965             relationship = serviceInstance.getRelationshipList().getRelationship();
 966             Relationship relation = relationship.stream()
 967                     .filter(relate -> "connectivity".equalsIgnoreCase(relate.getRelatedTo()))
 968                     .findAny()
 969                     .orElse(null);
 970             try {
 971                 String connectivityinstanceid = relation.getRelatedLink().substring(relation.getRelatedLink().lastIndexOf("/") + 1);
 972                 connectivity = getConnectivityInfo(connectivityinstanceid);
 973                 connectivityparams = new ObjectMapper().readValue(connectivity.toString(), HashMap.class);
 974
 975                 connode.setId(connectivityparams.get("connectivityId").toString());
 976                 connode.setShape("circularImage");
 977                 connode.setImage("./assets/treeTopology/connectivity.png");
 978                 connode.setLabel("Connectivity");
 979                 connode.setColor("Green");
 980                 Map<String, Object> datanode = new HashMap<String, Object>();
 981                 for (String key : vpnparams) {
 982                     if (key.equalsIgnoreCase("ebs"))
 983                         datanode.put("Service Type", connectivityparams.get(key));
 984                     else
 985                         datanode.put(key, connectivityparams.get(key));
 986                 }
 987
 988                 connode.setDataNode(new ObjectMapper().writeValueAsString(datanode));
 989                 nodes.add(connode);
 990
 991             } catch (IOException e) {
 992                logger.info("IO Exception occured " + e.getMessage());
 993             }
 994             //Query Connectivity : End
 995
 996
 997             //Query VPN : Begin
 998             Relationship vpnrelation = connectivity.getRelationshipList().getRelationship().stream()
 999                     .filter(relate -> "vpn-binding".equalsIgnoreCase(relate.getRelatedTo()))
1000                     .findAny()
1001                     .orElse(null);
1002             String vpnid = vpnrelation.getRelatedLink().substring(vpnrelation.getRelatedLink().lastIndexOf("/") + 1);
1003             VpnBinding vpnBinding = new VpnBinding();
1004             VpnInformation vpnInformation = new VpnInformation();
1005             try {
1006                 vpnBinding = getSOTNPinterfaceByVpnId(vpnid);
1007                 vpnInformation = vpnBinding.getVpnBinding().get(0);
1008             } catch (Exception e) {
1009                 logger.info("Exception occured " + e.getMessage());
1010             }
1011             Node vpn = new Node();
1012             vpn.setId(vpnInformation.getVpnId());
1013             vpn.setShape("circularImage");
1014             vpn.setImage("./assets/treeTopology/vpnbinding.png");
1015             vpn.setLabel("VPN Binding");
1016             vpn.setColor("Green");
1017             ObjectMapper mapper = new ObjectMapper();
1018             Map<String, Object> props = mapper.convertValue(vpnInformation, Map.class);
1019             props.remove("relationship-list");
1020             props.remove("resource-version");
1021             props.remove("vpn-region");
1022             props.remove("vpn-id");
1023             vpn.setDataNode(new ObjectMapper().writeValueAsString(props));
1024             nodes.add(vpn);
1025             Edge connectivitytovpnedge = new Edge();
1026             connectivitytovpnedge.setFrom(connode.getId());
1027             connectivitytovpnedge.setTo(vpn.getId());
1028             edges.add(connectivitytovpnedge);
1029
1030             //Query VPN : End
1031
1032             //Query access node : Begin
1033
1034             String srcnodeid = vpnInformation.getSrcAccessNodeId();
1035             Pnf srcpnf = new Pnf();
1036             srcpnf = getSOTNPnf(srcnodeid);
1037             Node srcpnfnode = new Node();
1038             Node dstpnfnode = new Node();
1039             srcpnfnode.setId(srcpnf.getPnfId());
1040             srcpnfnode.setShape("circularImage");
1041             srcpnfnode.setImage("./assets/treeTopology/accessnode.png");
1042             srcpnfnode.setLabel("Abstract Node");
1043             srcpnfnode.setColor("Green");
1044             ObjectMapper srcpnfmapper = new ObjectMapper();
1045             Map<String, Object> srcpnfprop = srcpnfmapper.convertValue(srcpnf, Map.class);
1046             srcpnfprop.remove("relationship-list");
1047             srcpnfprop.remove("resource-version");
1048             srcpnfprop.remove("in-maint");
1049             srcpnfprop.remove("admin-status");
1050             srcpnfnode.setDataNode(new ObjectMapper().writeValueAsString(srcpnfprop));
1051             nodes.add(srcpnfnode);
1052
1053             String dstnodeid = vpnInformation.getDstAccessNodeId();
1054             boolean foundnode = false;
1055             for (Node node : nodes) {
1056                 if (node.getId().equalsIgnoreCase(dstnodeid)) {
1057                     foundnode = true;
1058                     break;
1059                 }
1060             }
1061             if (!foundnode) {
1062                 Pnf dstpnf = new Pnf();
1063                 dstpnf = getSOTNPnf(dstnodeid);
1064
1065                 dstpnfnode.setId(dstpnf.getPnfId());
1066                 dstpnfnode.setShape("circularImage");
1067                 dstpnfnode.setImage("./assets/treeTopology/accessnode.png");
1068                 dstpnfnode.setLabel("Abstract Node");
1069                 dstpnfnode.setColor("Green");
1070                 ObjectMapper dstpnfmapper = new ObjectMapper();
1071                 Map<String, Object> dstpnfprop = dstpnfmapper.convertValue(dstpnf, Map.class);
1072                 dstpnfprop.remove("relationship-list");
1073                 dstpnfprop.remove("resource-version");
1074                 dstpnfprop.remove("in-maint");
1075                 dstpnfnode.setDataNode(new ObjectMapper().writeValueAsString(srcpnfprop));
1076                 nodes.add(dstpnfnode);
1077             }
1078
1079             //Query P Interfaces
1080
1081
1082             List<Relationship> vpnpinterfacerelation = vpnInformation.getRelationshipList().getRelationship().stream()
1083                     .filter(relate -> "p-interface".equalsIgnoreCase(relate.getRelatedTo())).collect(Collectors.toList());
1084             for (Relationship temprel : vpnpinterfacerelation) {
1085                 String pinterfaceid = temprel.getRelatedLink().substring(temprel.getRelatedLink().lastIndexOf("/") + 1);
1086                 String parentaccessnode = "";
1087
1088
1089                 RelationshipData[] pnfrelatedprop = temprel.getRelationshipData();
1090                 for (RelationshipData temp : pnfrelatedprop) {
1091                     if ("pnf.pnf-name".equalsIgnoreCase(temp.getRelationshipKey())) {
1092                         parentaccessnode = temp.getRelationshipValue();
1093                         break;
1094                     }
1095                 }
1096                 try {
1097                     Pinterface pinterface = new Pinterface();
1098                     pinterface = getTerminationPoint(parentaccessnode, pinterfaceid);
1099                     Node vpnpinterface = new Node();
1100                     vpnpinterface.setId(pinterface.getInterfaceName());
1101                     vpnpinterface.setShape("circularImage");
1102                     vpnpinterface.setImage("./assets/treeTopology/tpoint.png");
1103                     vpnpinterface.setLabel("Termination Point");
1104                     vpnpinterface.setColor("Green");
1105                     ObjectMapper vpnpintmapper = new ObjectMapper();
1106                     Map<String, Object> vpnpintprops = vpnpintmapper.convertValue(pinterface, Map.class);
1107                     vpnpintprops.remove("relationship-list");
1108                     vpnpintprops.remove("resource-version");
1109                     vpnpintprops.remove("in-maint");
1110                     vpnpinterface.setDataNode(new ObjectMapper().writeValueAsString(vpnpintprops));
1111                     nodes.add(vpnpinterface);
1112                     Edge iallotedtopnfedge = new Edge();
1113                     iallotedtopnfedge.setFrom(vpn.getId());
1114                     iallotedtopnfedge.setTo(vpnpinterface.getId());
1115                     edges.add(iallotedtopnfedge);
1116                     String toedge = "";
1117                     for (Node node : nodes) {
1118                         if (node.getId().equalsIgnoreCase(parentaccessnode)) {
1119                             toedge = node.getId();
1120                             break;
1121                         }
1122                     }
1123                     Edge tptopnfedge = new Edge();
1124                     tptopnfedge.setFrom(toedge);
1125                     tptopnfedge.setTo(vpnpinterface.getId());
1126                     edges.add(tptopnfedge);
1127                     int logicallinkcount = 0;
1128                     logicallinkcount = pinterface.getRelationshipList().getRelationship().stream().filter(prelation -> prelation.getRelatedTo()
1129                             .equalsIgnoreCase("logical-link")).collect(Collectors.toList()).size();
1130                     if (logicallinkcount > 0) {
1131                         tpinterface = pinterface.getRelationshipList().getRelationship().stream().filter(prelation -> prelation.getRelatedTo()
1132                                 .equalsIgnoreCase("logical-link")).collect(Collectors.toList());
1133                         logicallinkparentid = pinterface.getInterfaceName();
1134                     }
1135
1136                 } catch (Exception e) {
1137                     logger.info("Exception occured " + e.getMessage());
1138                 }
1139             }
1140             //Query logical Link : Begin
1141
1142             Relationship logicallinkrelation = tpinterface.get(0);
1143             String linkname = logicallinkrelation.getRelatedLink().substring(logicallinkrelation.getRelatedLink().lastIndexOf("/") + 1);
1144             try {
1145                 logicallink = getSOTNLinkbyName(linkname);
1146                 Node logiclink = new Node();
1147                 logiclink.setId(logicallink.getLinkName());
1148                 logiclink.setShape("circularImage");
1149                 logiclink.setImage("./assets/treeTopology/logicallink.png");
1150                 logiclink.setLabel("Logical Link");
1151                 logiclink.setColor("Green");
1152                 ObjectMapper linkmapper = new ObjectMapper();
1153                 Map<String, Object> linkpropprops = linkmapper.convertValue(logicallink, Map.class);
1154                 linkpropprops.remove("relationship-list");
1155                 linkpropprops.remove("resource-version");
1156                 linkpropprops.remove("in-maint");
1157                 logiclink.setDataNode(new ObjectMapper().writeValueAsString(linkpropprops));
1158                 nodes.add(logiclink);
1159                 Edge tptologicallinkedge = new Edge();
1160                 tptologicallinkedge.setFrom(logicallinkparentid);
1161                 tptologicallinkedge.setTo(logiclink.getId());
1162                 edges.add(tptologicallinkedge);
1163             } catch (Exception e) {
1164                 logger.info("Exception occured " + e.getMessage());
1165             }
1166
1167             List<Relationship> llrelationlist = logicallink.getRelationshipList().getRelationship().stream().filter(llrelation -> llrelation.getRelatedTo()
1168                     .equalsIgnoreCase("p-interface")).collect(Collectors.toList());
1169
1170
1171             String externalnode = "";
1172             for (Relationship llrel : llrelationlist) {
1173                 externalnode = "";
1174                 RelationshipData[] llrelatedprop = llrel.getRelationshipData();
1175                 for (RelationshipData temp : llrelatedprop) {
1176                     if ("pnf.pnf-name".equalsIgnoreCase(temp.getRelationshipKey())) {
1177                         externalnode = temp.getRelationshipValue();
1178                         break;
1179                     }
1180                 }
1181                 if (!dstnodeid.equalsIgnoreCase(externalnode)) {
1182                     Pinterface extpinterface = new Pinterface();
1183                     String pinterfaceid = llrel.getRelatedLink().substring(llrel.getRelatedLink().lastIndexOf("/") + 1);
1184                     extpinterface = getTerminationPoint(externalnode, pinterfaceid);
1185                     Node extpinterfacenode = new Node();
1186                     extpinterfacenode.setId(extpinterface.getInterfaceName());
1187                     extpinterfacenode.setShape("circularImage");
1188                     extpinterfacenode.setImage("./assets/treeTopology/tpoint.png");
1189                     extpinterfacenode.setLabel("Termination Point");
1190                     extpinterfacenode.setColor("Green");
1191                     ObjectMapper vpnpintmapper = new ObjectMapper();
1192                     Map<String, Object> vpnpintprops = vpnpintmapper.convertValue(extpinterface, Map.class);
1193                     vpnpintprops.remove("relationship-list");
1194                     vpnpintprops.remove("resource-version");
1195                     vpnpintprops.remove("in-maint");
1196                     extpinterfacenode.setDataNode(new ObjectMapper().writeValueAsString(vpnpintprops));
1197                     nodes.add(extpinterfacenode);
1198                     Edge iallotedtopnfedge = new Edge();
1199                     iallotedtopnfedge.setFrom(logicallink.getLinkName());
1200                     iallotedtopnfedge.setTo(extpinterfacenode.getId());
1201                     edges.add(iallotedtopnfedge);
1202                     for (Node node : nodes) {
1203                         if (node.getId().equalsIgnoreCase(externalnode)) {
1204                             ext_tp_found = true;
1205                             break;
1206                         }
1207                     }
1208
1209                     if (!ext_tp_found) {
1210                         extpnf = getSOTNPnf(externalnode);
1211                         Node extpnfnode = new Node();
1212                         extpnfnode.setId(extpnf.getPnfId());
1213                         extpnfnode.setShape("circularImage");
1214                         extpnfnode.setImage("./assets/treeTopology/accessnode.png");
1215                         extpnfnode.setLabel("External Abstract Node");
1216                         extpnfnode.setColor("Green");
1217                         ObjectMapper linkmapper = new ObjectMapper();
1218                         Map<String, Object> exttpprops = linkmapper.convertValue(extpnf, Map.class);
1219                         exttpprops.remove("relationship-list");
1220                         exttpprops.remove("resource-version");
1221                         exttpprops.remove("in-maint");
1222                         exttpprops.remove("admin-status");
1223                         extpnfnode.setDataNode(new ObjectMapper().writeValueAsString(exttpprops));
1224                         nodes.add(extpnfnode);
1225                         Edge exttpedge = new Edge();
1226                         exttpedge.setFrom(extpinterface.getInterfaceName());
1227                         exttpedge.setTo(extpnf.getPnfId());
1228                         edges.add(exttpedge);
1229                     }
1230                 }
1231             }
1232
1233
1234             Relationship externalaairel = logicallink.getRelationshipList().getRelationship().stream()
1235                     .filter(relate -> "ext-aai-network".equalsIgnoreCase(relate.getRelatedTo()))
1236                     .findAny()
1237                     .orElse(null);
1238             if (null != externalaairel) {
1239                 Node externalaai = new Node();
1240                 externalaai.setId("EXT_AAI");
1241                 externalaai.setShape("circularImage");
1242                 externalaai.setImage("./assets/treeTopology/extaai.png");
1243                 externalaai.setLabel("External AAI");
1244                 externalaai.setColor("Green");
1245                 Map<String, Object> extaaiprops = new HashMap<>();
1246                 String extaainame = externalaairel.getRelatedLink().substring(externalaairel.getRelatedLink().lastIndexOf("/") + 1);
1247                 extaaiprops.put("Name", extaainame);
1248                 externalaai.setDataNode(new ObjectMapper().writeValueAsString(extaaiprops));
1249                 nodes.add(externalaai);
1250                 Edge extaaiedge = new Edge();
1251                 extaaiedge.setFrom(extpnf.getPnfId());
1252                 extaaiedge.setTo(externalaai.getId());
1253                 edges.add(extaaiedge);
1254             }
1255             //Query logical Link : End
1256         }
1257         resourceResponse.setNodes(nodes);
1258         resourceResponse.setEdges(edges);
1259         logger.info("jsonresponse: "+jsonresponse);
1260         return resourceResponse.toString();
1261     }
1262
1263
1264     @Override
1265     public String getService(String subscriptionType, String instanceid) {
1266         ServiceEstimationBean serviceEstimationBean = new ServiceEstimationBean();
1267         ServiceInstance serviceInstance = null;
1268         ServiceInstance siteservice = null;
1269         ModelConfig modelConfig = readFile();
1270         Map<String, Model> modelInfo = readConfigToMap(modelConfig);
1271         String customerId = modelConfig.getSubscriberId();
1272         Map<String, Object> connectivityparams;
1273         List<String> vpnparams = new ArrayList<String>(Arrays.asList("cir", "eir", "ebs", "ethtSvcName"));
1274         List<Map<String, Object>> sites = new LinkedList<Map<String, Object>>();
1275         List<Map<String, Object>> vpnmap = new LinkedList<Map<String, Object>>();
1276         Map<String, Object> vpninformation = new HashMap<String, Object>();
1277         String jsonresponse = "";
1278         //----------------------------- GET SERVICE INSTANCE INFORMATION FROM AAI : BEGIN ---------------------------------------
1279         try {
1280             serviceInstance = getServiceInstancesInfo(customerId, subscriptionType, instanceid);
1281             if (serviceInstance == null) {
1282                 logger.info("Query site Service Instance information failed. No service information found for customer "
1283                         + customerId + " and Service Type " + subscriptionType);
1284                 return null;
1285             } else {
1286                 logger.info("Instance Name is:"+serviceInstance.getServiceInstanceName()+", Instance ID is: "+ serviceInstance.getServiceInstanceId());
1287             }
1288         } catch (Exception e) {
1289             logger.info("Query Service Instance information failed. No service information found for customer "
1290                     + customerId + " and Service Type " + subscriptionType);
1291             return null;
1292         }
1293
1294         List<Relationship> relationship = serviceInstance.getRelationshipList().getRelationship().stream().filter(relation -> relation.getRelatedTo().equalsIgnoreCase("allotted-resource")).collect(Collectors.toList());
1295         if (relationship.size() > 0 && relationship != null) {
1296             // This is SOTN service
1297             connectivityparams = new HashMap<String, Object>();
1298             relationship = serviceInstance.getRelationshipList().getRelationship();
1299             for (Relationship relation : relationship) {
1300                 String strRelationship = relation.getRelatedTo().toLowerCase();
1301                 switch (strRelationship) {
1302                     case "connectivity":
1303                         try {
1304                             String connectivityinstanceid = relation.getRelatedLink().substring(relation.getRelatedLink().lastIndexOf("/") + 1);
1305                             Connectivity connectivity = getConnectivityInfo(connectivityinstanceid);
1306                             connectivityparams = new ObjectMapper().readValue(connectivity.toString(), HashMap.class);
1307
1308                         } catch (IOException e) {
1309                             logger.info("IO Exception occured " + e.getMessage());
1310                         }
1311
1312                         break;
1313                     //case "allotted-resource":
1314                     case "service-instance":
1315                         String siteserviceinstanceid = relation.getRelatedLink().substring(relation.getRelatedLink().lastIndexOf("/") + 1);
1316                         String cvlan = "";
1317                         Map<String, Object> site;
1318                         try {
1319                             siteservice = getServiceInstancesInfo(customerId, subscriptionType, siteserviceinstanceid);
1320                             if (siteservice == null) {
1321                                 logger.info("Query site Service Instance information failed. No service information found for customer "
1322                                         + customerId + " and Service Type " + subscriptionType);
1323                                 return null;
1324                             }
1325                         } catch (Exception e) {
1326                             logger.info("Query site Instance information failed. No service information found for customer "
1327                                     + customerId + " and Service Type " + subscriptionType);
1328                             return null;
1329                         }
1330                         List<Relationship> ssrelationship = siteservice.getRelationshipList().getRelationship().stream()
1331                                 .filter(siterelation -> siterelation.getRelatedTo().equalsIgnoreCase("site-resource") ||
1332                                         siterelation.getRelatedTo().equalsIgnoreCase("allotted-resource")).collect(Collectors.toList());
1333
1334                         if (ssrelationship.size() > 0) {
1335                             Relationship allotrel = ssrelationship.stream()
1336                                     .filter(relate -> "allotted-resource".equalsIgnoreCase(relate.getRelatedTo()))
1337                                     .findAny()
1338                                     .orElse(null);
1339                             String allottedResourceId = allotrel.getRelatedLink().substring(allotrel.getRelatedLink().lastIndexOf("/") + 1);
1340                             try {
1341                                 AllottedResource allottedResource = getAllottedResource(customerId, subscriptionType, siteserviceinstanceid, allottedResourceId);
1342                                 cvlan = allottedResource.getCvlan();
1343                             } catch (Exception e) {
1344                             }
1345
1346                             Relationship siterel = ssrelationship.stream()
1347                                     .filter(relate -> "site-resource".equalsIgnoreCase(relate.getRelatedTo()))
1348                                     .findAny()
1349                                     .orElse(null);
1350                             String siteResourceID = siterel.getRelatedLink().substring(siterel.getRelatedLink().lastIndexOf("/") + 1);
1351                             try {
1352                                 SiteResource resource = getSiteResource(siteResourceID);
1353                                 site = new HashMap<String, Object>();
1354                                 site.put("siteId", resource.getSiteResourceId());
1355                                 site.put("siteName", resource.getSiteResourceName());
1356                                 site.put("description", resource.getDescription());
1357                                 site.put("role", "dsvpn-hub");
1358                                 site.put("cvlan", cvlan);
1359                                 List<Relationship> complexRelationship = resource.getRelationshipList().getRelationship()
1360                                         .stream().filter(rel -> rel.getRelatedTo().equalsIgnoreCase("complex"))
1361                                         .collect(Collectors.toList());
1362                                 for (Relationship complexrelation : complexRelationship) {
1363                                     String complexID = complexrelation.getRelatedLink().substring(complexrelation.getRelatedLink().lastIndexOf("/") + 1);
1364                                     ComplexObj complex = getComplexData(complexID);    //getSiteResourceInfo
1365                                     site.put("address", complex.getCity());
1366                                     site.put("location", complex.getCity());
1367                                     site.put("zipCode", complex.getPostalCode());
1368                                 }
1369 //                                Map<String, String> attr = new HashMap<String, String>();
1370 //                                attr.put("cvlan",cvlan);
1371 //                                attr.put("accessnodeid",connectivityparams.get("accessNodeId").toString());
1372 //                                attr.put("accessltpid",connectivityparams.get("accessLtpId").toString());
1373 //                                site.put("attribute", attr);
1374                                 sites.add(site);
1375                             } catch (Exception e) {
1376                                 logger.info("Query Service Instance information failed. No service information found for customer "
1377                                         + customerId + " and Service Type " + subscriptionType);
1378                                 return null;
1379                             }
1380                         } else {
1381                             String requestinput = siteservice.getInputparameters();
1382                             E2EServiceInstanceRequest e2eserviceRequest = new E2EServiceInstanceRequest();
1383                             ObjectMapper mapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
1384                             try {
1385                                 e2eserviceRequest = mapper.readValue(requestinput.toString(), new TypeReference<E2EServiceInstanceRequest>() {
1386                                 });
1387                             } catch (IOException e) {
1388                                 logger.info("Query remove Service Instance information failed" + e.getMessage());
1389                             }
1390
1391                             HashMap<String, ?> requestInputs = e2eserviceRequest.getService().getParameters().getRequestInputs();
1392                             site = new HashMap<String, Object>();
1393                             //Map<String, Object> attr = new HashMap<String, Object>();
1394                             for (Map.Entry<String, ?> e : requestInputs.entrySet()) {
1395                                 if (e.getKey().contains("name")) {
1396                                     site.put("siteName", (String) requestInputs.get(e.getKey()));
1397
1398                                 } else if (e.getKey().contains("description")) {
1399                                     site.put("description", (String) requestInputs.get(e.getKey()));
1400
1401                                 } else if (e.getKey().contains("role")) {
1402                                     site.put("role", (String) requestInputs.get(e.getKey()));
1403
1404                                 } else if (e.getKey().contains("address")) {
1405                                     site.put("location", (String) requestInputs.get(e.getKey()));
1406
1407                                 } else if (e.getKey().contains("postcode")) {
1408                                     site.put("zipCode", (String) requestInputs.get(e.getKey()));
1409
1410                                 } else if (e.getKey().contains("cVLAN")) {
1411                                     site.put("cvlan", (String) requestInputs.get(e.getKey()));
1412
1413                                 }
1414                             }
1415                             //site.put("attribute", attr);
1416                             sites.add(site);
1417                         }
1418
1419
1420 //                        //------------------------------------------------------------- Old logic begin --------------
1421 //                        try
1422 //                        {
1423 //                            String allottedResourceId = relation.getRelatedLink().substring(relation.getRelatedLink().lastIndexOf("/") + 1);
1424 //                            String siteserviceintanceid = "";
1425 //                            List<RelationshipDatum> relationshipDataum = relation.getRelationshipData();
1426 //                            for(RelationshipDatum datum : relationshipDataum)
1427 //                            {
1428 //                                if(datum.getRelationshipKey().equalsIgnoreCase("service-instance.service-instance-id")){
1429 //                                siteserviceintanceid=datum.getRelationshipValue();
1430 //                                break;
1431 //                                }
1432 //                            }
1433 //                            AllottedResource allottedResource = getAllottedResource(customerId,subscriptionType,siteserviceintanceid, allottedResourceId);
1434 //                            List<Relationship> allottedRelationship = allottedResource.getRelationshipList().getRelationship();
1435 //                            for(Relationship allrelation : allottedRelationship)
1436 //                            {
1437 //                                String strAllRelationship = allrelation.getRelatedTo().toLowerCase();
1438 //                                if("service-instance".equalsIgnoreCase(strAllRelationship))
1439 //                                {
1440 //                                    String allottedServiceId = allrelation.getRelatedLink().substring(allrelation.getRelatedLink().lastIndexOf("/") + 1);
1441 //                                    if(!allottedServiceId.equalsIgnoreCase(instanceid))
1442 //                                    {
1443 //                                        try {
1444 //                                            ServiceInstance allottedserviceInstance = getServiceInstancesInfo(customerId, subscriptionType, allottedServiceId);
1445 //                                            if (serviceInstance != null)
1446 //                                            {
1447 //                                                List<Relationship> siteRelationship = allottedserviceInstance.getRelationshipList()
1448 //                                                        .getRelationship().stream().filter(siterelation -> siterelation.getRelatedTo()
1449 //                                                                .equalsIgnoreCase("site-resource")).collect(Collectors.toList());
1450 //                                                for(Relationship siterelation : siteRelationship) {
1451 //                                                    String siteResourceID = siterelation.getRelatedLink().substring(siterelation.getRelatedLink().lastIndexOf("/") + 1);
1452 //                                                    SiteResource resource = getSiteResource(siteResourceID);    //getSiteResourceInfo
1453 //                                                    Map<String, String> site = new HashMap<String, String>();
1454 //                                                    site.put("siteId",resource.getSiteResourceId());
1455 //                                                    site.put("siteName",resource.getSiteResourceName());
1456 //                                                    site.put("description",resource.getDescription());
1457 //
1458 //                                                    List<Relationship> complexRelationship = resource.getRelationshipList().getRelationship();
1459 //                                                    for(Relationship complexrelation : siteRelationship) {
1460 //                                                        String complexID = complexrelation.getRelatedLink().substring(complexrelation.getRelatedLink().lastIndexOf("/") + 1);
1461 //                                                        ComplexObj complex = getComplexData(complexID);    //getSiteResourceInfo
1462 //                                                        site.put("address",complex.getCity());
1463 //                                                        site.put("zipCode",complex.getPostalCode());
1464 //                                                    }
1465 //                                                    sites.add(site);
1466 //                                                }
1467 //
1468 //                                            }
1469 //
1470 //                                        } catch (Exception e) {
1471 //                                            logger.info("Query Service Instance information failed. No service information found for customer "
1472 //                                                    + customerId + " and Service Type " + subscriptionType + "and Service Instance ID  "+instanceid);
1473 //                                        }
1474 //                                    }
1475 //                                }
1476 //                            }
1477 //                            connectivityparams = new ObjectMapper().readValue(allottedResource.toString(), HashMap.class);
1478 //                        }catch (IOException e)
1479 //                        {
1480 //
1481 //                        }
1482 //
1483 //                        //-------------------------------------------------------- old logic end here.--------------------------------------------
1484
1485                         break;
1486                     default:
1487                         break;
1488
1489                 }
1490             }
1491
1492             //create response bean
1493             //connectivityparams.remove()
1494             Map<String, Object> response = new HashMap<String, Object>();
1495             for (String key : vpnparams) {
1496                 if (key.equalsIgnoreCase("ebs"))
1497                     response.put("Service Type", connectivityparams.get(key));
1498                 else if (key.equalsIgnoreCase("ethtSvcName"))
1499                     response.put("Service Name", connectivityparams.get(key));
1500                 else
1501                     response.put(key, connectivityparams.get(key));
1502             }
1503             vpninformation.put("vpnName", connectivityparams.get("ethtSvcName"));
1504             vpninformation.put("vpnId", connectivityparams.get("connectivityId"));
1505             vpninformation.put("vpnType", "Hub-Spoke");
1506             vpninformation.put("vpnBandwidth", connectivityparams.get("cbs"));
1507             vpninformation.put("vpnThreshold", connectivityparams.get("eir"));
1508             vpninformation.put("sites", sites);
1509             vpnmap.add(vpninformation);
1510             response.put("vpnInformations", vpnmap);
1511
1512             try {
1513
1514                 jsonresponse = new ObjectMapper().writeValueAsString(response);
1515                 logger.info("jsonresponse:"+ jsonresponse);
1516             } catch (IOException e) {
1517                 logger.info("IO Exception occured " + e.getMessage());
1518             }
1519
1520         } else {
1521             //This is DWAN service
1522             logger.info("There is no logic for get Service");
1523         }
1524
1525         //----------------------------- GET SERVICE INSTANCE INFORMATION FROM AAI : END -----------------------------------------
1526         return jsonresponse;
1527     }
1528
1529     @Override
1530     public String getSOTNInstantiationstatus(String instanceid) {
1531         ServiceInstantiationResponse serviceInstantiationResponse = new ServiceInstantiationResponse();
1532         ServiceInstance infraInstance = null;
1533         ServiceInstance siteInstance = null;
1534         ModelConfig modelConfig = readFile();
1535         String subscriptionType = modelConfig.getSubscriptionType();
1536         String customerId = modelConfig.getSubscriberId();
1537         int activatedsitecount = 0;
1538         try {
1539             infraInstance = getServiceInstancesInfo(customerId, subscriptionType, instanceid);
1540             if (infraInstance == null)
1541                 return null;
1542         } catch (Exception e) {
1543              logger.info("Query Service Instance information failed. No service information found for customer "
1544                  + customerId + " and Service Type " + subscriptionType);
1545             return null;
1546         }
1547         if (infraInstance.getOrchestrationstatus().equalsIgnoreCase("Assigned") || infraInstance.getOrchestrationstatus().equalsIgnoreCase("Active")) {
1548             activatedsitecount = activatedsitecount + 1;
1549             List<Relationship> infrarelationlist = infraInstance.getRelationshipList().getRelationship().stream().filter(relation -> relation.getRelatedTo().equalsIgnoreCase("service-instance"))
1550                     .collect(Collectors.toList());
1551             for (Relationship relation : infrarelationlist) {
1552                 String siteservice = relation.getRelatedLink().substring(relation.getRelatedLink().lastIndexOf("/") + 1);
1553                 try {
1554                     siteInstance = getServiceInstancesInfo(customerId, subscriptionType, siteservice);
1555                     if (infraInstance == null) {
1556                         serviceInstantiationResponse.setStatus("0");
1557                         return serviceInstantiationResponse.toString();
1558                     }
1559                 } catch (Exception e) {
1560                     logger.info("Query Service Instance information failed. No service information found for customer "
1561                       + customerId + " and Service Type " + subscriptionType);
1562                     serviceInstantiationResponse.setStatus("0");
1563                     return serviceInstantiationResponse.toString();
1564                 }
1565                 if (siteInstance.getOrchestrationstatus().equalsIgnoreCase("Assigned") || siteInstance.getOrchestrationstatus().equalsIgnoreCase("Active")) {
1566                     activatedsitecount = activatedsitecount + 1;
1567                 } else {
1568                     break;
1569                 }
1570             }
1571         } else {
1572             serviceInstantiationResponse.setStatus("0");
1573         }
1574         if (activatedsitecount == 3)
1575             serviceInstantiationResponse.setStatus("1");
1576         return serviceInstantiationResponse.toString();
1577     }
1578 }