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