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