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(),
 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             $log
 434                 .debug("AaiService:getLcpCloudRegionTenantList: globalCustomerId: "
 435                     + globalCustomerId);
 436             var url =   COMPONENT.AAI_GET_TENANTS
 437                 + globalCustomerId + COMPONENT.FORWARD_SLASH + serviceType + COMPONENT.ASSIGN + Math.random();
 438
 439             $http.get(url,
 440                 {
 441                     timeout : PropertyService
 442                         .getServerResponseTimeoutMsec()
 443                 }).then(function(response) {
 444                 var lcpCloudRegionTenants = [];
 445                 var aaiLcpCloudRegionTenants = response.data;
 446
 447                 for (var i = 0; i < aaiLcpCloudRegionTenants.length; i++) {
 448                     lcpCloudRegionTenants.push({
 449                         "cloudRegionId": aaiLcpCloudRegionTenants[i][COMPONENT.CLOUD_REGION_ID],
 450                         "cloudOwner": aaiLcpCloudRegionTenants[i][COMPONENT.CLOUD_OWNER],
 451                         "tenantName": aaiLcpCloudRegionTenants[i][COMPONENT.TENANT_NAME],
 452                         "tenantId": aaiLcpCloudRegionTenants[i][COMPONENT.TENANT_ID],
 453                         "isPermitted": aaiLcpCloudRegionTenants[i][COMPONENT.IS_PERMITTED]});
 454                 }
 455
 456                 successCallbackFunction(lcpCloudRegionTenants);
 457             }).catch(function(error) {
 458                 (UtilityService.runHttpErrorHandler(error.data, error.status));
 459             })
 460         },
 461         getSubscribers : function(successCallbackFunction) {
 462             $log
 463                 .debug("AaiService:getSubscribers");
 464             var url =  FIELD.ID.AAI_GET_SUBSCRIBERS + COMPONENT.ASSIGN + Math.random();
 465
 466             $http.get(url,
 467                 {
 468                     timeout : PropertyService
 469                         .getServerResponseTimeoutMsec()
 470                 }).then(function(response) {
 471                 if (response.data) {
 472                     successCallbackFunction(response.data.customer);
 473                 } else {
 474                     successCallbackFunction([]);
 475                 }
 476             })["catch"]
 477             (UtilityService.runHttpErrorHandler);
 478         },
 479         getProvOptionsFromSystemProp : function(successCallbackFunction) {
 480             $log
 481                 .debug("AaiService:getProvOptionsFromSystemProp");
 482             var url =  COMPONENT.GET_SYSTEM_PROP_VNF_PROV_STATUS_PATH;
 483
 484             $http.get(url,
 485                 {
 486                     timeout : PropertyService
 487                         .getServerResponseTimeoutMsec()
 488                 }).then(function(response) {
 489                 if (response.data) {
 490                     successCallbackFunction(response);
 491                 } else {
 492                     successCallbackFunction([]);
 493                 }
 494             })["catch"]
 495             (UtilityService.runHttpErrorHandler);
 496         },
 497         getLoggedInUserID : function(successCallbackFunction, catchCallbackFunction) {
 498             $log
 499                 .debug("AaiService:getLoggedInUserID");
 500             var url = COMPONENT.GET_USER_ID;
 501
 502             $http.get(url,
 503                 {
 504                     transformResponse: [function (data) {
 505                         return data;
 506                     }],
 507                     timeout : PropertyService
 508                         .getServerResponseTimeoutMsec()
 509                 }).then(function(response) {
 510                 if (response.data) {
 511                     successCallbackFunction(response);
 512                 } else {
 513                     successCallbackFunction([]);
 514                 }
 515             })["catch"] (function(response, status) {
 516                 if (catchCallbackFunction) {
 517                     catchCallbackFunction();
 518                 }
 519                 UtilityService.runHttpErrorHandler(response, status);
 520             })
 521         },
 522         getServices : function(successCallbackFunction) {
 523             $log
 524                 .debug("AaiService:getServices");
 525             var url =  COMPONENT.AAI_GET_SERVICES + COMPONENT.ASSIGN + Math.random();
 526
 527             $http.get(url,
 528                 {
 529                     timeout: PropertyService
 530                         .getServerResponseTimeoutMsec()
 531                 }).then(function (response) {
 532                 if (response.data) {
 533                     successCallbackFunction(response);
 534                 } else {
 535                     successCallbackFunction([]);
 536                 }
 537             })["catch"]
 538             (UtilityService.runHttpErrorHandler);
 539         },
 540
 541         getAicZones: function (successCallbackFunction) {
 542             $log
 543                 .debug("getAicZones:getAicZones");
 544             var url = COMPONENT.AAI_GET_AIC_ZONES +COMPONENT.ASSIGN + Math.random();
 545
 546             $http.get(url,
 547                 {
 548                     timeout : PropertyService
 549                         .getServerResponseTimeoutMsec()
 550                 }).then(function(response) {
 551                 if (response.data) {
 552                     successCallbackFunction(response);
 553                 } else {
 554                     successCallbackFunction([]);
 555                 }
 556             })["catch"]
 557             (UtilityService.runHttpErrorHandler);},
 558         getAicZoneForPNF: function (globalCustomerId,serviceType,serviceInstanceId,successCallbackFunction) {
 559             $log
 560                 .debug("getAicZones:getAicZones");
 561             var url = COMPONENT.AAI_GET_AIC_ZONE_FOR_PNF
 562                 .replace('@serviceInstanceId', serviceInstanceId)
 563                 .replace('@globalCustomerId', globalCustomerId)
 564                 .replace('@serviceType', serviceType);
 565             $http.get(url,
 566                 {
 567                     timeout : PropertyService
 568                         .getServerResponseTimeoutMsec()
 569                 }).then(function(response) {
 570                 successCallbackFunction(response.data);
 571             })["catch"]
 572             (UtilityService.runHttpErrorHandler);},
 573
 574         getServiceModels : function(globalCustomerId,serviceType,successCallbackFunction) {
 575             $log
 576                 .debug("AaiService:getServices");
 577             var url =   COMPONENT.AAI_GET_SERVICES + COMPONENT.FORWARD_SLASH+globalCustomerId+ COMPONENT.FORWARD_SLASH +serviceType+COMPONENT.ASSIGN + Math.random();
 578
 579             $http.get(url,
 580                 {
 581                     timeout : PropertyService
 582                         .getServerResponseTimeoutMsec()
 583                 }).then(function(response) {
 584                 if (response.data) {
 585                     successCallbackFunction(response);
 586                 } else {
 587                     successCallbackFunction([]);
 588                 }
 589             })["catch"]
 590             (UtilityService.runHttpErrorHandler);
 591         },
 592         getServiceModelsByServiceType : function(namedQueryId,globalCustomerId,serviceType,successCallbackFunction) {
 593             $log
 594                 .debug("AaiService:getServiceModelsByServiceType");
 595             var url =   COMPONENT.AAI_GET_SERVICES_BY_TYPE+COMPONENT.FORWARD_SLASH+namedQueryId+COMPONENT.FORWARD_SLASH+globalCustomerId+COMPONENT.FORWARD_SLASH +serviceType+COMPONENT.ASSIGN + Math.random();
 596
 597             $http.get(url,
 598                 {
 599                     timeout : PropertyService
 600                         .getServerResponseTimeoutMsec()
 601                 }).then(function(response) {
 602                 if (response.data) {
 603                     successCallbackFunction(response);
 604                 } else {
 605                     successCallbackFunction([]);
 606                 }
 607             })["catch"]
 608             (UtilityService.runHttpErrorHandler);
 609         },
 610
 611                 getVnfsByCustomerIdAndServiceType: function(globalSubscriberId, serviceType){
 612             var deferred = $q.defer();
 613
 614             if (UtilityService.hasContents(globalSubscriberId) &&
 615                                 UtilityService.hasContents(serviceType) ) {
 616
 617                 $http.get(COMPONENT.AAI_GET_VNF_BY_CUSTOMERID_AND_SERVICETYPE + globalSubscriberId + COMPONENT.FORWARD_SLASH
 618                                         + serviceType )
 619                     .success(function (response) {
 620                         if(response) {
 621                             deferred.resolve({data: response});
 622                         } else {
 623                             deferred.resolve({data: []});
 624                         }
 625                     }).error(function (data, status, headers, config) {
 626                     deferred.reject({message: data, status: status});
 627                 });
 628             }
 629
 630             return deferred.promise;
 631         },
 632
 633         getVnfVersionsByInvariantId: function(modelInvariantId){
 634             var deferred = $q.defer();
 635
 636             if (UtilityService.hasContents(modelInvariantId)) {
 637                 var body = {"versions": modelInvariantId};
 638                 $http.post(( COMPONENT.AAI_GET_VERSION_BY_INVARIANT_ID),body)
 639
 640                     .success(function (response) {
 641                         if(response) {
 642                             deferred.resolve({data: response});
 643                         } else {
 644                             deferred.resolve({data: []});
 645                         }
 646                     }).error(function (data, status, headers, config) {
 647                     deferred.reject({message: data, status: status});
 648                 });
 649             }
 650
 651             return deferred.promise;
 652         },
 653
 654
 655
 656         getSubscriberServiceTypes: function(subscriberUuid) {
 657             var deferred = $q.defer();
 658             $log.debug("AaiService:getSubscriberServiceTypes: subscriberUuid: " + subscriberUuid);
 659
 660             if (UtilityService.hasContents(subscriberUuid)) {
 661                 $http.get(COMPONENT.AAI_SUB_DETAILS_PATH + subscriberUuid + COMPONENT.ASSIGN + Math.random())
 662                     .success(function (response) {
 663                         if(response && [FIELD.ID.SERVICE_SUBSCRIPTIONS]) {
 664                             deferred.resolve({data: response[FIELD.ID.SERVICE_SUBSCRIPTIONS][FIELD.ID.SERVICE_SUBSCRIPTION]});
 665                         } else {
 666                             deferred.resolve({data: []});
 667                         }
 668                     }).error(function (data, status, headers, config) {
 669                     deferred.reject({message: data, status: status});
 670                 });
 671             }
 672
 673             return deferred.promise;
 674         },
 675         getVnfInstancesList: function(globalSubscriberId, serviceType, modelVersionId ,modelInvariantId, cloudRegionId)  {
 676             var deferred = $q.defer();
 677             $http.get([COMPONENT.AAI_GET_VNF_INSTANCES_LIST,
 678                     globalSubscriberId,
 679                     serviceType,
 680                     modelVersionId,
 681                     modelInvariantId,
 682                     cloudRegionId]
 683                 .join(COMPONENT.FORWARD_SLASH))
 684                 .success(function (response) {
 685                     deferred.resolve(response);
 686                 }).error(function (data, status) {
 687                     deferred.reject({message: data, status: status});
 688             });
 689             return deferred.promise;
 690         },
 691         getPnfInstancesList: function (globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegionId, equipVendor, equipModel) {
 692             var deferred = $q.defer();
 693             $http.get([COMPONENT.AAI_GET_PNF_INSTANCES_LIST,
 694                     globalCustomerId, serviceType,
 695                     modelVersionId, modelInvariantId,
 696                     cloudRegionId,
 697                     equipVendor, equipModel
 698                 ].join(COMPONENT.FORWARD_SLASH))
 699                 .success(function (response) {
 700                     deferred.resolve(response);
 701                 }).error(function (data, status) {
 702                 deferred.reject({message: data, status: status});
 703             });
 704             return deferred.promise;
 705         },
 706         getByUri: function(uri)  {
 707             var deferred = $q.defer();
 708
 709             $http.get(COMPONENT.AAI_GET_BY_URI + uri)
 710                 .success(function (response) {
 711                     deferred.resolve({data: []});
 712                 }).error(function (data, status, headers, config) {
 713                     deferred.reject({message: data, status: status});
 714                 });
 715
 716             return deferred.promise;
 717         },
 718         getConfiguration: function(configurationId)  {
 719             var deferred = $q.defer();
 720
 721             $http.get(COMPONENT.AAI_GET_CONFIGURATION + configurationId)
 722                 .success(function (response) {
 723                     deferred.resolve({data: []});
 724                 }).error(function (data, status, headers, config) {
 725                 deferred.reject({message: data, status: status});
 726             });
 727
 728             return deferred.promise;
 729         },
 730
 731         getInstanceGroupsByVNFInstanceId: function (vnf_instance_id, successCallback, errorCallback) {
 732             var url = COMPONENT.AAI_GET_INSTANCE_GROUPS_BY_VNF_INSTANCE_ID_PATH + "/" + vnf_instance_id;
 733
 734             $http.get(url, {}, {
 735                 timeout: PropertyService.getServerResponseTimeoutMsec()
 736             }).then(function (response) {
 737                 successCallback(response);
 738             }, function (response) {
 739                 errorCallback(response);
 740             });
 741         },
 742
 743         postPOMBAverificationRequest: function (url, data, config) {
 744             $http.post(url, data, config)
 745                 .success(function (data, status, headers, config) {
 746                     //If at some point in the future the result should be handled - this should be the entry point.
 747                     log.debug("POMBA was called successfully with data: " + data);
 748                 })
 749                 .error(function (data, status, header, config) {
 750                     log.debug("Error: " +
 751                         "Data: " + data +
 752                         "status: " + status +
 753                         "headers: " + header +
 754                         "config: " + config);
 755                 });
 756         },
 757
 758         getHomingData: function(vnfInstanceId, vfModuleId)  {
 759             var url = COMPONENT.AAI_GET_HOMING_DATA.replace('@vnfInstanceId', vnfInstanceId)
 760                 .replace('@vfModuleId', vfModuleId);
 761
 762             var deferred = $q.defer();
 763
 764             $http.get(url)
 765                 .success(function (response) {
 766                     deferred.resolve({data: response});
 767                 }).error(function (data, status, headers, config) {
 768                 deferred.reject({message: data, status: status});
 769             });
 770
 771             return deferred.promise;
 772
 773         },
 774
 775         removeVendorFromCloudOwner: function(cloudOwner) {
 776             // Handle the case where cloud owner is formatted
 777             // like "{vendor}-{cloud-name}"
 778             return cloudOwner.trim().replace(/^[^-]*-/, '');
 779         }
 780     };
 781 };
 782
 783 appDS2.factory("AaiService", ["$http", "$log", "PropertyService",
 784     "UtilityService", "COMPONENT", "FIELD", "$q", "featureFlags", AaiService]);