vid-app-common/src/main/webapp/app/vid/scripts/services/aaiService.js

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * VID
   4  * ================================================================================
   5  * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 "use strict";
  22
  23 var AaiService = function ($http, $log, PropertyService, UtilityService, COMPONENT, FIELD, $q, featureFlags) {
  24
  25     function getServiceInstance(serviceInstanceIdentifier, findBy) {
  26         serviceInstanceIdentifier.trim();
  27
  28         return $http.get(COMPONENT.AAI_GET_SERVICE_INSTANCE_PATH + serviceInstanceIdentifier + "/" + findBy + "?r=" + Math.random(), {}, {
  29             timeout: PropertyService.getServerResponseTimeoutMsec()
  30         });
  31     }
  32
  33     function getPnfByName(pnfName) {
  34         var deferred = $q.defer();
  35         var url = COMPONENT.AAI_GET_PNF_BY_NAME+ encodeURIComponent(pnfName)  ;
  36         var config = { timeout: PropertyService.getServerResponseTimeoutMsec() };
  37
  38         $http.get(url, config)
  39             .success(function (response) {
  40                 deferred.resolve({data: response});
  41             })
  42             .error(function(data, status, headers, config) {
  43                 deferred.reject({message: data, status: status});
  44             });
  45
  46         return deferred.promise;
  47     }
  48     function getGlobalCustomerIdFromServiceInstanceResponse(response) {
  49         var globalCustomerId = "";
  50         if (angular.isArray(response.data[FIELD.ID.RESULT_DATA])) {
  51             var customerIndex = 5;
  52             var customerIdIndex = 6;
  53             var itemIndex = 0;
  54
  55             var item = response.data[FIELD.ID.RESULT_DATA][itemIndex];
  56             var url = item[FIELD.ID.RESOURCE_LINK];
  57             var urlParts = url.split("/");
  58             if (urlParts[customerIndex] === FIELD.ID.CUSTOMER) {
  59                 globalCustomerId = urlParts[customerIdIndex];
  60             }
  61         }
  62         return globalCustomerId;
  63     }
  64
  65     function searchServiceInstances(query) {
  66         return $http.get( COMPONENT.SEARCH_SERVICE_INSTANCES  + query, {}, {
  67             timeout : PropertyService.getServerResponseTimeoutMsec()
  68         }).then(function (response) {
  69             var displayData = response.data[FIELD.ID.SERVICE_INSTANCES];
  70             if (!displayData || !displayData.length) {
  71                 displayData = [{
  72                     globalCustomerId    : null,
  73                     subscriberName      : null,
  74                     serviceType                 : FIELD.PROMPT.NO_SERVICE_SUB,
  75                     serviceInstanceId   : FIELD.PROMPT.NO_SERVICE_INSTANCE
  76                 }];
  77             }
  78             return {displayData: displayData};
  79         });
  80     };
  81
  82     function getJoinedQueryString(queries) {
  83         return queries.filter(function (val) {return val;}).join("&");
  84     }
  85
  86     return {
  87         getSubscriberName : function(globalCustomerId,
  88                                      successCallbackFunction) {
  89             $log
  90                 .debug("AaiService:getSubscriberName: globalCustomerId: "
  91                     + globalCustomerId);
  92             $http.get(
  93                 COMPONENT.AAI_SUB_DETAILS_PATH
  94                 + globalCustomerId + COMPONENT.ASSIGN + Math.random(),
  95                 {
  96                     timeout : PropertyService
  97                         .getServerResponseTimeoutMsec()
  98                 }).then(function(response) {
  99                 var result = {};
 100                 if (response.data) {
 101                     result.subscriberName = response.data[FIELD.ID.SUBNAME];
 102                     result.serviceSubscriptions = response.data[FIELD.ID.SERVICE_SUBSCRIPTIONS];
 103                 }
 104                 successCallbackFunction(result);
 105             })["catch"]
 106             (UtilityService.runHttpErrorHandler);
 107         },
 108
 109         runNamedQuery : function (namedQueryId, globalCustomerId, serviceType, serviceInstanceId, successCallback, errorCallback) {
 110
 111             var url = COMPONENT.AAI_SUB_VIEWEDIT_PATH +
 112                 COMPONENT.FORWARD_SLASH + encodeURIComponent(namedQueryId) +
 113                 COMPONENT.FORWARD_SLASH + encodeURIComponent(globalCustomerId) +
 114                 COMPONENT.FORWARD_SLASH + encodeURIComponent(serviceType) +
 115                 COMPONENT.FORWARD_SLASH + encodeURIComponent(serviceInstanceId);
 116             return $http.get(url, {}, {
 117
 118
 119                 timeout : PropertyService.getServerResponseTimeoutMsec()
 120             }).then(function(response) {
 121                 if (response.data != null) {
 122                     successCallback(response);
 123                 } else {
 124                     errorCallback(response);
 125                 }
 126             }, function(response) {
 127                 errorCallback(response);
 128             });
 129         },
 130
 131
 132         getVNFInformationByServiceTypeAndId : function (globalCustomerId, serviceType, serviceInstanceId, successCallback, errorCallback) {
 133
 134             var url = COMPONENT.AAI_GET_VNF_INFO +
 135                 COMPONENT.FORWARD_SLASH + encodeURIComponent(globalCustomerId) +
 136                 COMPONENT.FORWARD_SLASH + encodeURIComponent(serviceType) +
 137                 COMPONENT.FORWARD_SLASH + encodeURIComponent(serviceInstanceId);
 138             $http.get(url, {}, {
 139                 timeout : PropertyService.getServerResponseTimeoutMsec()
 140             }).then(function(response) {
 141                 if (response.data != null) {
 142                     successCallback(response);
 143                 } else {
 144                     errorCallback(response);
 145                 }
 146             }, function(response) {
 147                 errorCallback(response);
 148             });
 149         },
 150
 151         getPNFInformationByServiceTypeAndId : function (globalCustomerId, serviceType, serviceInstanceId, successCallback, errorCallback) {
 152
 153             var url = COMPONENT.AAI_GET_PNF_INSTANCE +
 154                 COMPONENT.FORWARD_SLASH + encodeURIComponent(globalCustomerId) +
 155                 COMPONENT.FORWARD_SLASH + encodeURIComponent(serviceType) +
 156                 COMPONENT.FORWARD_SLASH + encodeURIComponent(serviceInstanceId);
 157             $http.get(url, {}, {
 158                 timeout : PropertyService.getServerResponseTimeoutMsec()
 159             }).then(function(response) {
 160                 if (response.data != null) {
 161                     successCallback(response);
 162                 } else {
 163                     errorCallback(response);
 164                 }
 165             }, function(response) {
 166                 errorCallback(response);
 167             });
 168         },
 169
 170         getCRInformationByInstanceId : function (serviceInstanceId) {
 171
 172             var deferred = $q.defer();
 173
 174             var url = COMPONENT.AAI_GET_CR_INSTANCE +
 175                 COMPONENT.FORWARD_SLASH + encodeURIComponent(serviceInstanceId);
 176             $http.get(url, {}, {
 177                 timeout : PropertyService.getServerResponseTimeoutMsec()
 178             }).then(function(response) {
 179                 if (response.data != null) {
 180                     deferred.resolve(response);
 181                 } else {
 182                     deferred.resolve(response);
 183                 }
 184             }, function(response) {
 185                 deferred.resolve(response);
 186             });
 187             return deferred.promise;
 188         },
 189
 190         searchServiceInstances: searchServiceInstances,
 191
 192         getModelVersionId: function (subscriberId, instanceId) {
 193             var globalCustomerIdQuery = COMPONENT.SELECTED_SUBSCRIBER_SUB_PATH + subscriberId;
 194             var serviceInstanceQuery = COMPONENT.SELECTED_SERVICE_INSTANCE_SUB_PATH + instanceId;
 195
 196             var query = "?" + getJoinedQueryString([globalCustomerIdQuery, serviceInstanceQuery]);
 197
 198             var deferred = $q.defer();
 199
 200             searchServiceInstances(query).then(function (response) {
 201                 var displayData = response.displayData;
 202                 if (displayData[0] && displayData[0].aaiModelVersionId) {
 203                     deferred.resolve(displayData[0].aaiModelVersionId);
 204                 } else {
 205                     deferred.reject(FIELD.ERROR.MODEL_VERSION_ID_MISSING);
 206                 }
 207             }).catch(function (err) {
 208                 deferred.reject(err);
 209             });
 210
 211             return deferred.promise;
 212         },
 213
 214         getSubDetails : function(selectedSubscriber, selectedServiceInstance, successCallback, errorCallback) {
 215             var subscriber;
 216             var displayData;
 217             $http.get( COMPONENT.AAI_SUB_DETAILS_PATH  + selectedSubscriber, {}, {
 218
 219
 220                 timeout : PropertyService.getServerResponseTimeoutMsec()
 221             }).then(function(response) {
 222                 displayData = [];
 223                 subscriber = response.data;
 224                 var subscriberName = subscriber[FIELD.ID.SUBNAME];
 225                 if (subscriber[FIELD.ID.SERVICE_SUBSCRIPTIONS] != null) {
 226                     angular.forEach(subscriber[FIELD.ID.SERVICE_SUBSCRIPTIONS][FIELD.ID.SERVICE_SUBSCRIPTION], function(serviceSubscription, key) {
 227                         var serviceInstanceId = [];
 228                         var serviceType = "";
 229                         if (serviceSubscription[FIELD.ID.SERVICETYPE] != null) {
 230                             serviceType = serviceSubscription[FIELD.ID.SERVICETYPE];
 231                         } else {
 232                             serviceType = FIELD.PROMPT.NO_SERVICE_SUB;
 233                         }
 234                         if (serviceSubscription[FIELD.ID.SERVICE_INSTANCES] != null) {
 235                             angular.forEach(serviceSubscription[FIELD.ID.SERVICE_INSTANCES][FIELD.ID.SERVICE_INSTANCE], function(instValue, instKey) {
 236                                 // put them together, i guess
 237                                 var inst = { "serviceInstanceId": instValue[FIELD.ID.SERVICE_INSTANCE_ID],
 238                                     "aaiModelInvariantId": instValue[FIELD.ID.MODEL_INVAR_ID],
 239                                     "aaiModelVersionId": instValue[FIELD.ID.MODEL_VERSION_ID],
 240                                     "serviceInstanceName": instValue[FIELD.ID.SERVICE_INSTANCE_NAME]
 241                                 };
 242                                 if (selectedServiceInstance != null) {
 243                                     if ((instValue[FIELD.ID.SERVICE_INSTANCE_ID] == selectedServiceInstance ) || (instValue[FIELD.ID.SERVICE_INSTANCE_NAME] == selectedServiceInstance)) {
 244                                         serviceInstanceId.push(inst);
 245                                     }
 246                                 } else {
 247                                     serviceInstanceId.push(inst);
 248                                 }
 249                             });
 250                         } else {
 251                             serviceInstanceId = [ FIELD.PROMPT.NO_SERVICE_INSTANCE ];
 252                         }
 253                         angular.forEach(serviceInstanceId, function(subVal, subKey) {
 254                             displayData.push({
 255                                 globalCustomerId        : selectedSubscriber,
 256                                 subscriberName          : subscriberName,
 257                                 serviceType             : serviceType,
 258                                 serviceInstanceId       : subVal.serviceInstanceId,
 259                                 aaiModelInvariantId             : subVal.aaiModelInvariantId,
 260                                 aaiModelVersionId
 261                                     : subVal.aaiModelVersionId,
 262                                 serviceInstanceName     : subVal.serviceInstanceName,
 263                                 isPermitted: serviceSubscription[FIELD.ID.IS_PERMITTED]
 264                             });
 265                         });
 266                     });
 267                 } else {
 268                     displayData.push({
 269                         globalCustomerId        : selectedSubscriber,
 270                         subscriberName          : subscriberName,
 271                         serviceType             : FIELD.PROMPT.NO_SERVICE_SUB,
 272                         serviceInstanceId       : FIELD.PROMPT.NO_SERVICE_INSTANCE
 273                     });
 274                 }
 275                 successCallback(displayData, subscriberName);
 276             }, function(response) {
 277                 errorCallback(response);});
 278         },
 279
 280         getSubList : function(successCallback, errorCallback ) {
 281
 282             $http.get( FIELD.ID.AAI_GET_FULL_SUBSCRIBERS, {}, {
 283
 284
 285                 timeout : PropertyService.getServerResponseTimeoutMsec()
 286             }).then(function(response) {
 287                 var customerList = [];
 288                 if (response.data.customer != null) {
 289                     angular.forEach(response.data.customer, function(subVal, subKey) {
 290                         var cust = { "globalCustomerId": subVal[FIELD.ID.GLOBAL_CUSTOMER_ID], "subscriberName": subVal[FIELD.ID.SUBNAME],
 291                             "isPermitted": subVal[FIELD.ID.IS_PERMITTED], };
 292                         customerList.push(cust);
 293                     });
 294                     successCallback(customerList);
 295                 } else {
 296                     errorCallback(response);
 297                 }
 298             },function(response) {
 299                 errorCallback(response);
 300             });
 301         },
 302
 303         getServiceInstance : getServiceInstance,
 304         getPnfByName : getPnfByName,
 305
 306         getGlobalCustomerIdByInstanceIdentifier : function(serviceInstanceIdentifier, findBy) {
 307             serviceInstanceIdentifier.trim();
 308
 309             return getServiceInstance(serviceInstanceIdentifier, findBy)
 310                 .then(function (response) {
 311                     return getGlobalCustomerIdFromServiceInstanceResponse(response);
 312             });
 313         },
 314
 315         getMultipleValueParamQueryString: function(values, paramSubPath) {
 316             if (values.length) {
 317                 return paramSubPath + values.filter(function (val) {return val;}).join("&" + paramSubPath);
 318             }
 319         },
 320
 321         getJoinedQueryString: getJoinedQueryString,
 322
 323         getServices2 : function(successCallback, errorCallback ) {
 324
 325             $http.get( FIELD.ID.AAI_GET_SERVICES, {}, {
 326
 327
 328                 timeout : PropertyService.getServerResponseTimeoutMsec()
 329             }).then(function(response) {
 330                 var customerList = [];
 331                 if (response.data != null) {
 332                     var serviceIdList = [];
 333                     angular.forEach(response.data, function(value, key) {
 334                         angular.forEach(value, function(subVal, key) {
 335                             var newVal = { "id" : subVal[FIELD.ID.SERVICE_ID], "description" : subVal[FIELD.ID.SERVICE_DESCRIPTION] ,
 336                                 "isPermitted" : subVal[FIELD.ID.IS_PERMITTED]
 337
 338                             };serviceIdList.push(newVal);
 339                         });
 340                     });
 341                     successCallback(serviceIdList);
 342                 } else {
 343                     errorCallback(response);
 344                 }
 345             },function(response) {
 346                 errorCallback(response);
 347             });
 348         },
 349
 350         getPortMirroringData: function (ids) {
 351             var defer = $q.defer();
 352
 353             var url = COMPONENT.AAI_GET_PORT_MIRRORING_CONFIGS_DATA + '?configurationIds=' + ids.join(',');
 354             $http.get(url).then(function (res) {
 355                 defer.resolve(res);
 356             }).catch(function (err) {
 357                 $log.error(err);
 358                 defer.resolve({});
 359             });
 360
 361             return defer.promise;
 362
 363         },
 364
 365         getPortMirroringSourcePorts : function (ids) {
 366             var defer = $q.defer();
 367             var url = COMPONENT.AAI_GET_PORT_MIRRORING_SOURCE_PORTS +'?configurationIds=' +  ids.join(',');
 368             $http.get(url).then(function(res){
 369                 defer.resolve(res);
 370             }).catch(function(err) {
 371                 $log.error(err);
 372                 defer.resolve({});
 373             });
 374             return defer.promise;
 375         },
 376
 377         getVlansByNetworksMapping : function (globalCustomerId, serviceType, serviceInstanceId, sdcModelUuid) {
 378             var defer = $q.defer();
 379             if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_PRESENT_PROVIDER_NETWORKS_ASSOCIATIONS)) {
 380                 var url = COMPONENT.AAI_GET_PROVIDER_NETWORKS_ASSOCIATIONS + '?'
 381                     + 'globalCustomerId=' + globalCustomerId
 382                     + '&serviceType=' + serviceType
 383                     + '&serviceInstanceId=' + serviceInstanceId
 384                     + '&sdcModelUuid=' + sdcModelUuid
 385                 ;
 386
 387                 $http.get(url).then(function(res){
 388                     defer.resolve(res.data);
 389                 }).catch(function(err) {
 390                     $log.error(err);
 391                     defer.resolve({});
 392                 });
 393
 394             } else {
 395                 defer.resolve({});
 396             }
 397             return defer.promise;
 398         },
 399
 400         getSubscriptionServiceTypeList : function(globalCustomerId,
 401                                                   successCallbackFunction) {
 402             $log
 403                 .debug("AaiService:getSubscriptionServiceTypeList: globalCustomerId: "
 404                     + globalCustomerId);
 405             if ( UtilityService.hasContents(globalCustomerId) ) {
 406                 $http.get(
 407                     COMPONENT.AAI_SUB_DETAILS_PATH
 408                     + globalCustomerId + COMPONENT.ASSIGN + Math.random() + COMPONENT.AAI_OMIT_SERVICE_INSTANCES + true,
 409                     {
 410                         timeout : PropertyService
 411                             .getServerResponseTimeoutMsec()
 412                     }).then(function(response) {
 413                     if (response.data && response.data[FIELD.ID.SERVICE_SUBSCRIPTIONS]) {
 414                         var serviceTypes = [];
 415                         var serviceSubscriptions = response.data[FIELD.ID.SERVICE_SUBSCRIPTIONS][FIELD.ID.SERVICE_SUBSCRIPTION];
 416
 417                         for (var i = 0; i < serviceSubscriptions.length; i++) {
 418                             serviceTypes.push({
 419                                 "name":serviceSubscriptions[i][FIELD.ID.SERVICETYPE],
 420                                 "isPermitted": serviceSubscriptions[i][FIELD.ID.IS_PERMITTED],
 421                                 "id": i
 422                             });}
 423                         successCallbackFunction(serviceTypes);
 424                     } else {
 425                         successCallbackFunction([]);
 426                     }
 427                 })["catch"]
 428                 (UtilityService.runHttpErrorHandler);
 429             }
 430         },
 431         getLcpCloudRegionTenantList : function(globalCustomerId, serviceType,
 432                                                successCallbackFunction) {
 433             let self = this;
 434             $log
 435                 .debug("AaiService:getLcpCloudRegionTenantList: globalCustomerId: "
 436                     + globalCustomerId);
 437             var url =   COMPONENT.AAI_GET_TENANTS
 438                 + globalCustomerId + COMPONENT.FORWARD_SLASH + serviceType + COMPONENT.ASSIGN + Math.random();
 439
 440             $http.get(url,
 441                 {
 442                     timeout : PropertyService
 443                         .getServerResponseTimeoutMsec()
 444                 }).then(function(response) {
 445                 var lcpCloudRegionTenants = [];
 446                 var aaiLcpCloudRegionTenants = response.data;
 447
 448                 for (var i = 0; i < aaiLcpCloudRegionTenants.length; i++) {
 449                     var cloudOwner = aaiLcpCloudRegionTenants[i][COMPONENT.CLOUD_OWNER];
 450                     var cloudRegionId = aaiLcpCloudRegionTenants[i][COMPONENT.CLOUD_REGION_ID];
 451                     var cloudRegionOptionId = self.cloudRegionOptionId(cloudOwner, cloudRegionId);
 452
 453                     lcpCloudRegionTenants.push({
 454                         "cloudOwner": cloudOwner,
 455                         "cloudRegionId": cloudRegionId,
 456                         "cloudRegionOptionId": cloudRegionOptionId,
 457                         "tenantName": aaiLcpCloudRegionTenants[i][COMPONENT.TENANT_NAME],
 458                         "tenantId": aaiLcpCloudRegionTenants[i][COMPONENT.TENANT_ID],
 459                         "isPermitted": aaiLcpCloudRegionTenants[i][COMPONENT.IS_PERMITTED]});
 460                 }
 461
 462                 successCallbackFunction(lcpCloudRegionTenants);
 463             }).catch(function(error) {
 464                 (UtilityService.runHttpErrorHandler(error.data, error.status));
 465             })
 466         },
 467         getSubscribers : function(successCallbackFunction) {
 468             $log
 469                 .debug("AaiService:getSubscribers");
 470             var url =  FIELD.ID.AAI_GET_SUBSCRIBERS + COMPONENT.ASSIGN + Math.random();
 471
 472             $http.get(url,
 473                 {
 474                     timeout : PropertyService
 475                         .getServerResponseTimeoutMsec()
 476                 }).then(function(response) {
 477                 if (response.data) {
 478                     successCallbackFunction(response.data.customer);
 479                 } else {
 480                     successCallbackFunction([]);
 481                 }
 482             })["catch"]
 483             (UtilityService.runHttpErrorHandler);
 484         },
 485         getProvOptionsFromSystemProp : function(successCallbackFunction) {
 486             $log
 487                 .debug("AaiService:getProvOptionsFromSystemProp");
 488             var url =  COMPONENT.GET_SYSTEM_PROP_VNF_PROV_STATUS_PATH;
 489
 490             $http.get(url,
 491                 {
 492                     timeout : PropertyService
 493                         .getServerResponseTimeoutMsec()
 494                 }).then(function(response) {
 495                 if (response.data) {
 496                     successCallbackFunction(response);
 497                 } else {
 498                     successCallbackFunction([]);
 499                 }
 500             })["catch"]
 501             (UtilityService.runHttpErrorHandler);
 502         },
 503         getLoggedInUserID : function(successCallbackFunction, catchCallbackFunction) {
 504             $log
 505                 .debug("AaiService:getLoggedInUserID");
 506             var url = COMPONENT.GET_USER_ID;
 507
 508             $http.get(url,
 509                 {
 510                     transformResponse: [function (data) {
 511                         return data;
 512                     }],
 513                     timeout : PropertyService
 514                         .getServerResponseTimeoutMsec()
 515                 }).then(function(response) {
 516                 if (response.data) {
 517                     successCallbackFunction(response);
 518                 } else {
 519                     successCallbackFunction([]);
 520                 }
 521             })["catch"] (function(response, status) {
 522                 if (catchCallbackFunction) {
 523                     catchCallbackFunction();
 524                 }
 525                 UtilityService.runHttpErrorHandler(response, status);
 526             })
 527         },
 528         getServices : function(successCallbackFunction) {
 529             $log
 530                 .debug("AaiService:getServices");
 531             var url =  COMPONENT.AAI_GET_SERVICES + COMPONENT.ASSIGN + Math.random();
 532
 533             $http.get(url,
 534                 {
 535                     timeout: PropertyService
 536                         .getServerResponseTimeoutMsec()
 537                 }).then(function (response) {
 538                 if (response.data) {
 539                     successCallbackFunction(response);
 540                 } else {
 541                     successCallbackFunction([]);
 542                 }
 543             })["catch"]
 544             (UtilityService.runHttpErrorHandler);
 545         },
 546
 547         getAicZones: function (successCallbackFunction) {
 548             $log
 549                 .debug("getAicZones:getAicZones");
 550             var url = COMPONENT.AAI_GET_AIC_ZONES +COMPONENT.ASSIGN + Math.random();
 551
 552             $http.get(url,
 553                 {
 554                     timeout : PropertyService
 555                         .getServerResponseTimeoutMsec()
 556                 }).then(function(response) {
 557                 if (response.data) {
 558                     successCallbackFunction(response);
 559                 } else {
 560                     successCallbackFunction([]);
 561                 }
 562             })["catch"]
 563             (UtilityService.runHttpErrorHandler);},
 564         getAicZoneForPNF: function (globalCustomerId,serviceType,serviceInstanceId,successCallbackFunction) {
 565             $log
 566                 .debug("getAicZones:getAicZones");
 567             var url = COMPONENT.AAI_GET_AIC_ZONE_FOR_PNF
 568                 .replace('@serviceInstanceId', serviceInstanceId)
 569                 .replace('@globalCustomerId', globalCustomerId)
 570                 .replace('@serviceType', serviceType);
 571             $http.get(url,
 572                 {
 573                     timeout : PropertyService
 574                         .getServerResponseTimeoutMsec()
 575                 }).then(function(response) {
 576                 successCallbackFunction(response.data);
 577             })["catch"]
 578             (UtilityService.runHttpErrorHandler);},
 579
 580         getServiceModels : function(globalCustomerId,serviceType,successCallbackFunction) {
 581             $log
 582                 .debug("AaiService:getServices");
 583             var url =   COMPONENT.AAI_GET_SERVICES + COMPONENT.FORWARD_SLASH+globalCustomerId+ COMPONENT.FORWARD_SLASH +serviceType+COMPONENT.ASSIGN + Math.random();
 584
 585             $http.get(url,
 586                 {
 587                     timeout : PropertyService
 588                         .getServerResponseTimeoutMsec()
 589                 }).then(function(response) {
 590                 if (response.data) {
 591                     successCallbackFunction(response);
 592                 } else {
 593                     successCallbackFunction([]);
 594                 }
 595             })["catch"]
 596             (UtilityService.runHttpErrorHandler);
 597         },
 598         getServiceModelsByServiceType : function(namedQueryId,globalCustomerId,serviceType,successCallbackFunction) {
 599             $log
 600                 .debug("AaiService:getServiceModelsByServiceType");
 601             var url =   COMPONENT.AAI_GET_SERVICES_BY_TYPE+COMPONENT.FORWARD_SLASH+namedQueryId+COMPONENT.FORWARD_SLASH+globalCustomerId+COMPONENT.FORWARD_SLASH +serviceType+COMPONENT.ASSIGN + Math.random();
 602
 603             $http.get(url,
 604                 {
 605                     timeout : PropertyService
 606                         .getServerResponseTimeoutMsec()
 607                 }).then(function(response) {
 608                 if (response.data) {
 609                     successCallbackFunction(response);
 610                 } else {
 611                     successCallbackFunction([]);
 612                 }
 613             })["catch"]
 614             (UtilityService.runHttpErrorHandler);
 615         },
 616
 617                 getVnfsByCustomerIdAndServiceType: function(globalSubscriberId, serviceType){
 618             var deferred = $q.defer();
 619
 620             if (UtilityService.hasContents(globalSubscriberId) &&
 621                                 UtilityService.hasContents(serviceType) ) {
 622
 623                 $http.get(COMPONENT.AAI_GET_VNF_BY_CUSTOMERID_AND_SERVICETYPE + globalSubscriberId + COMPONENT.FORWARD_SLASH
 624                                         + serviceType )
 625                     .success(function (response) {
 626                         if(response) {
 627                             deferred.resolve({data: response});
 628                         } else {
 629                             deferred.resolve({data: []});
 630                         }
 631                     }).error(function (data, status, headers, config) {
 632                     deferred.reject({message: data, status: status});
 633                 });
 634             }
 635
 636             return deferred.promise;
 637         },
 638
 639         getVnfVersionsByInvariantId: function(modelInvariantId){
 640             var deferred = $q.defer();
 641
 642             if (UtilityService.hasContents(modelInvariantId)) {
 643                 var body = {"versions": modelInvariantId};
 644                 $http.post(( COMPONENT.AAI_GET_VERSION_BY_INVARIANT_ID),body)
 645
 646                     .success(function (response) {
 647                         if(response) {
 648                             deferred.resolve({data: response});
 649                         } else {
 650                             deferred.resolve({data: []});
 651                         }
 652                     }).error(function (data, status, headers, config) {
 653                     deferred.reject({message: data, status: status});
 654                 });
 655             }
 656
 657             return deferred.promise;
 658         },
 659
 660
 661
 662         getSubscriberServiceTypes: function(subscriberUuid) {
 663             var deferred = $q.defer();
 664             $log.debug("AaiService:getSubscriberServiceTypes: subscriberUuid: " + subscriberUuid);
 665
 666             if (UtilityService.hasContents(subscriberUuid)) {
 667                 $http.get(COMPONENT.AAI_SUB_DETAILS_PATH + subscriberUuid + COMPONENT.ASSIGN + Math.random())
 668                     .success(function (response) {
 669                         if(response && [FIELD.ID.SERVICE_SUBSCRIPTIONS]) {
 670                             deferred.resolve({data: response[FIELD.ID.SERVICE_SUBSCRIPTIONS][FIELD.ID.SERVICE_SUBSCRIPTION]});
 671                         } else {
 672                             deferred.resolve({data: []});
 673                         }
 674                     }).error(function (data, status, headers, config) {
 675                     deferred.reject({message: data, status: status});
 676                 });
 677             }
 678
 679             return deferred.promise;
 680         },
 681         getVnfInstancesList: function(globalSubscriberId, serviceType, modelVersionId ,modelInvariantId, cloudRegionId)  {
 682             var deferred = $q.defer();
 683             $http.get([COMPONENT.AAI_GET_VNF_INSTANCES_LIST,
 684                     globalSubscriberId,
 685                     serviceType,
 686                     modelVersionId,
 687                     modelInvariantId,
 688                     cloudRegionId]
 689                 .join(COMPONENT.FORWARD_SLASH))
 690                 .success(function (response) {
 691                     deferred.resolve(response);
 692                 }).error(function (data, status) {
 693                     deferred.reject({message: data, status: status});
 694             });
 695             return deferred.promise;
 696         },
 697         getPnfInstancesList: function (globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegionId, equipVendor, equipModel) {
 698             var deferred = $q.defer();
 699             $http.get([COMPONENT.AAI_GET_PNF_INSTANCES_LIST,
 700                     globalCustomerId, serviceType,
 701                     modelVersionId, modelInvariantId,
 702                     cloudRegionId,
 703                     equipVendor, equipModel
 704                 ].join(COMPONENT.FORWARD_SLASH))
 705                 .success(function (response) {
 706                     deferred.resolve(response);
 707                 }).error(function (data, status) {
 708                 deferred.reject({message: data, status: status});
 709             });
 710             return deferred.promise;
 711         },
 712         getByUri: function(uri)  {
 713             var deferred = $q.defer();
 714
 715             $http.get(COMPONENT.AAI_GET_BY_URI + uri)
 716                 .success(function (response) {
 717                     deferred.resolve({data: []});
 718                 }).error(function (data, status, headers, config) {
 719                     deferred.reject({message: data, status: status});
 720                 });
 721
 722             return deferred.promise;
 723         },
 724         getConfiguration: function(configurationId)  {
 725             var deferred = $q.defer();
 726
 727             $http.get(COMPONENT.AAI_GET_CONFIGURATION + configurationId)
 728                 .success(function (response) {
 729                     deferred.resolve({data: []});
 730                 }).error(function (data, status, headers, config) {
 731                 deferred.reject({message: data, status: status});
 732             });
 733
 734             return deferred.promise;
 735         },
 736
 737         getInstanceGroupsByVNFInstanceId: function (vnf_instance_id, successCallback, errorCallback) {
 738             var url = COMPONENT.AAI_GET_INSTANCE_GROUPS_BY_VNF_INSTANCE_ID_PATH + "/" + vnf_instance_id;
 739
 740             $http.get(url, {}, {
 741                 timeout: PropertyService.getServerResponseTimeoutMsec()
 742             }).then(function (response) {
 743                 successCallback(response);
 744             }, function (response) {
 745                 errorCallback(response);
 746             });
 747         },
 748
 749         postPOMBAverificationRequest: function (url, data, config) {
 750             $http.post(url, data, config)
 751                 .success(function (data, status, headers, config) {
 752                     //If at some point in the future the result should be handled - this should be the entry point.
 753                     log.debug("POMBA was called successfully with data: " + data);
 754                 })
 755                 .error(function (data, status, header, config) {
 756                     log.debug("Error: " +
 757                         "Data: " + data +
 758                         "status: " + status +
 759                         "headers: " + header +
 760                         "config: " + config);
 761                 });
 762         },
 763
 764         cloudRegionOptionId: function (cloudOwner, cloudRegionId) {
 765             return ('option-' + cloudOwner + '-' + cloudRegionId).toLowerCase();
 766         },
 767
 768         getHomingData: function(vnfInstanceId, vfModuleId)  {
 769             let self = this;
 770             var url = COMPONENT.AAI_GET_HOMING_DATA.replace('@vnfInstanceId', vnfInstanceId)
 771                 .replace('@vfModuleId', vfModuleId);
 772
 773             var deferred = $q.defer();
 774
 775             $http.get(url)
 776                 .success(function (response) {
 777                     var cloudOwner = response[COMPONENT.CLOUD_OWNER];
 778                     var cloudRegionId = response[COMPONENT.CLOUD_REGION_ID];
 779                     if (cloudOwner && cloudRegionId) {
 780                         response["cloudRegionOptionId"] = self.cloudRegionOptionId(cloudOwner, cloudRegionId);
 781                     } else {
 782                         response["cloudRegionOptionId"] = null;
 783                     }
 784
 785                     deferred.resolve({data: response});
 786                 }).error(function (data, status, headers, config) {
 787                 deferred.reject({message: data, status: status});
 788             });
 789
 790             return deferred.promise;
 791
 792         },
 793
 794         removeVendorFromCloudOwner: function(cloudOwner) {
 795             // Handle the case where cloud owner is formatted
 796             // like "{vendor}-{cloud-name}"
 797             return cloudOwner.trim().replace(/^[^-]*-/, '');
 798         }
 799     };
 800 };
 801
 802 appDS2.factory("AaiService", ["$http", "$log", "PropertyService",
 803     "UtilityService", "COMPONENT", "FIELD", "$q", "featureFlags", AaiService]);