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