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
 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             $http.get(FIELD.ID.AAI_GET_SERVICES, {}, {
 351                 timeout: PropertyService.getServerResponseTimeoutMsec()
 352             }).then(function (response) {
 353                 if (response.data != null) {
 354                     var serviceIdList = [];
 355                     angular.forEach(response.data, function (value, key) {
 356                         angular.forEach(value, function (subVal, key) {
 357                             var newVal = {
 358                                 "id": subVal[FIELD.ID.SERVICE_ID], "description": subVal[FIELD.ID.SERVICE_DESCRIPTION],
 359                                 "isPermitted": subVal[FIELD.ID.IS_PERMITTED]
 360
 361                             };
 362                             serviceIdList.push(newVal);
 363                         });
 364                     });
 365                     successCallback(serviceIdList);
 366                 } else {
 367                     errorCallback(response);
 368                 }
 369             }, function (response) {
 370                 errorCallback(response);
 371             });
 372         },
 373
 374         getPortMirroringData: function (ids) {
 375             var defer = $q.defer();
 376
 377             var url = COMPONENT.AAI_GET_PORT_MIRRORING_CONFIGS_DATA + '?configurationIds=' + ids.join(',');
 378             $http.get(url).then(function (res) {
 379                 defer.resolve(res);
 380             }).catch(function (err) {
 381                 $log.error(err);
 382                 defer.resolve({});
 383             });
 384
 385             return defer.promise;
 386
 387         },
 388
 389         getPortMirroringSourcePorts: function (ids) {
 390             var defer = $q.defer();
 391             var url = COMPONENT.AAI_GET_PORT_MIRRORING_SOURCE_PORTS + '?configurationIds=' + ids.join(',');
 392             $http.get(url).then(function (res) {
 393                 defer.resolve(res);
 394             }).catch(function (err) {
 395                 $log.error(err);
 396                 defer.resolve({});
 397             });
 398             return defer.promise;
 399         },
 400
 401         getVlansByNetworksMapping: function (globalCustomerId, serviceType, serviceInstanceId, sdcModelUuid) {
 402             var defer = $q.defer();
 403             if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_PRESENT_PROVIDER_NETWORKS_ASSOCIATIONS)) {
 404                 var url = COMPONENT.AAI_GET_PROVIDER_NETWORKS_ASSOCIATIONS + '?'
 405                     + 'globalCustomerId=' + globalCustomerId
 406                     + '&serviceType=' + serviceType
 407                     + '&serviceInstanceId=' + serviceInstanceId
 408                     + '&sdcModelUuid=' + sdcModelUuid
 409                 ;
 410
 411                 $http.get(url).then(function (res) {
 412                     defer.resolve(res.data);
 413                 }).catch(function (err) {
 414                     $log.error(err);
 415                     defer.resolve({});
 416                 });
 417
 418             } else {
 419                 defer.resolve({});
 420             }
 421             return defer.promise;
 422         },
 423
 424         getSubscriptionServiceTypeList: function (globalCustomerId,
 425                                                   successCallbackFunction) {
 426             $log
 427                 .debug("AaiService:getSubscriptionServiceTypeList: globalCustomerId: "
 428                     + globalCustomerId);
 429             if (UtilityService.hasContents(globalCustomerId)) {
 430                 $http.get(
 431                     COMPONENT.AAI_SUB_DETAILS_PATH
 432                     + globalCustomerId + COMPONENT.ASSIGN + Math.random() + COMPONENT.AAI_OMIT_SERVICE_INSTANCES + true,
 433                     {
 434                         timeout: PropertyService
 435                             .getServerResponseTimeoutMsec()
 436                     }).then(function (response) {
 437                     if (response.data && response.data[FIELD.ID.SERVICE_SUBSCRIPTIONS]) {
 438                         var serviceTypes = [];
 439                         var serviceSubscriptions = response.data[FIELD.ID.SERVICE_SUBSCRIPTIONS][FIELD.ID.SERVICE_SUBSCRIPTION];
 440
 441                         for (var i = 0; i < serviceSubscriptions.length; i++) {
 442                             serviceTypes.push({
 443                                 "name": serviceSubscriptions[i][FIELD.ID.SERVICETYPE],
 444                                 "isPermitted": serviceSubscriptions[i][FIELD.ID.IS_PERMITTED],
 445                                 "id": i
 446                             });
 447                         }
 448                         successCallbackFunction(serviceTypes);
 449                     } else {
 450                         successCallbackFunction([]);
 451                     }
 452                 })["catch"]
 453                 (UtilityService.runHttpErrorHandler);
 454             }
 455         },
 456         getLcpCloudRegionTenantList: function (globalCustomerId, serviceType,
 457                                                successCallbackFunction) {
 458             let self = this;
 459             $log
 460                 .debug("AaiService:getLcpCloudRegionTenantList: globalCustomerId: "
 461                     + globalCustomerId);
 462             var url = COMPONENT.AAI_GET_TENANTS
 463                 + globalCustomerId + COMPONENT.FORWARD_SLASH + serviceType + COMPONENT.ASSIGN + Math.random();
 464
 465             $http.get(url,
 466                 {
 467                     timeout: PropertyService
 468                         .getServerResponseTimeoutMsec()
 469                 }).then(function (response) {
 470                 var lcpCloudRegionTenants = [];
 471                 var aaiLcpCloudRegionTenants = response.data;
 472
 473                 for (var i = 0; i < aaiLcpCloudRegionTenants.length; i++) {
 474                     var cloudOwner = aaiLcpCloudRegionTenants[i][COMPONENT.CLOUD_OWNER];
 475                     var cloudRegionId = aaiLcpCloudRegionTenants[i][COMPONENT.CLOUD_REGION_ID];
 476                     var cloudRegionOptionId = self.cloudRegionOptionId(cloudOwner, cloudRegionId);
 477
 478                     lcpCloudRegionTenants.push({
 479                         "cloudOwner": cloudOwner,
 480                         "cloudRegionId": cloudRegionId,
 481                         "cloudRegionOptionId": cloudRegionOptionId,
 482                         "tenantName": aaiLcpCloudRegionTenants[i][COMPONENT.TENANT_NAME],
 483                         "tenantId": aaiLcpCloudRegionTenants[i][COMPONENT.TENANT_ID],
 484                         "isPermitted": aaiLcpCloudRegionTenants[i][COMPONENT.IS_PERMITTED]
 485                     });
 486                 }
 487
 488                 successCallbackFunction(lcpCloudRegionTenants);
 489             }).catch(function (error) {
 490                 (UtilityService.runHttpErrorHandler(error.data, error.status));
 491             });
 492         },
 493         getSubscribers: function (successCallbackFunction) {
 494             $log
 495                 .debug("AaiService:getSubscribers");
 496             var url = FIELD.ID.AAI_GET_SUBSCRIBERS + COMPONENT.ASSIGN + Math.random();
 497
 498             $http.get(url,
 499                 {
 500                     timeout: PropertyService
 501                         .getServerResponseTimeoutMsec()
 502                 }).then(function (response) {
 503                 if (response.data) {
 504                     successCallbackFunction(response.data.customer);
 505                 } else {
 506                     successCallbackFunction([]);
 507                 }
 508             })["catch"]
 509             (UtilityService.runHttpErrorHandler);
 510         },
 511         getProvOptionsFromSystemProp: function (successCallbackFunction) {
 512             $log
 513                 .debug("AaiService:getProvOptionsFromSystemProp");
 514             var url = COMPONENT.GET_SYSTEM_PROP_VNF_PROV_STATUS_PATH;
 515
 516             $http.get(url,
 517                 {
 518                     timeout: PropertyService
 519                         .getServerResponseTimeoutMsec()
 520                 }).then(function (response) {
 521                 if (response.data) {
 522                     successCallbackFunction(response);
 523                 } else {
 524                     successCallbackFunction([]);
 525                 }
 526             })["catch"]
 527             (UtilityService.runHttpErrorHandler);
 528         },
 529         getLoggedInUserID: function (successCallbackFunction, catchCallbackFunction) {
 530             $log
 531                 .debug("AaiService:getLoggedInUserID");
 532             var url = COMPONENT.GET_USER_ID;
 533
 534             $http.get(url,
 535                 {
 536                     transformResponse: [function (data) {
 537                         return data;
 538                     }],
 539                     timeout: PropertyService
 540                         .getServerResponseTimeoutMsec()
 541                 }).then(function (response) {
 542                 if (response.data) {
 543                     successCallbackFunction(response);
 544                 } else {
 545                     successCallbackFunction([]);
 546                 }
 547             })["catch"](function (response, status) {
 548                 if (catchCallbackFunction) {
 549                     catchCallbackFunction();
 550                 }
 551                 UtilityService.runHttpErrorHandler(response, status);
 552             });
 553         },
 554         getServices: function (successCallbackFunction) {
 555             $log
 556                 .debug("AaiService:getServices");
 557             var url = COMPONENT.AAI_GET_SERVICES + COMPONENT.ASSIGN + Math.random();
 558
 559             $http.get(url,
 560                 {
 561                     timeout: PropertyService
 562                         .getServerResponseTimeoutMsec()
 563                 }).then(function (response) {
 564                 if (response.data) {
 565                     successCallbackFunction(response);
 566                 } else {
 567                     successCallbackFunction([]);
 568                 }
 569             })["catch"]
 570             (UtilityService.runHttpErrorHandler);
 571         },
 572
 573         getAicZones: function (successCallbackFunction) {
 574             $log
 575                 .debug("getAicZones:getAicZones");
 576             var url = COMPONENT.AAI_GET_AIC_ZONES + COMPONENT.ASSIGN + Math.random();
 577
 578             $http.get(url,
 579                 {
 580                     timeout: PropertyService
 581                         .getServerResponseTimeoutMsec()
 582                 }).then(function (response) {
 583                 if (response.data) {
 584                     successCallbackFunction(response);
 585                 } else {
 586                     successCallbackFunction([]);
 587                 }
 588             })["catch"]
 589             (UtilityService.runHttpErrorHandler);
 590         },
 591         getAicZoneForPNF: function (globalCustomerId, serviceType, serviceInstanceId, successCallbackFunction) {
 592             $log
 593                 .debug("getAicZones:getAicZones");
 594             var url = COMPONENT.AAI_GET_AIC_ZONE_FOR_PNF
 595                 .replace('@serviceInstanceId', serviceInstanceId)
 596                 .replace('@globalCustomerId', globalCustomerId)
 597                 .replace('@serviceType', serviceType);
 598             $http.get(url,
 599                 {
 600                     timeout: PropertyService
 601                         .getServerResponseTimeoutMsec()
 602                 }).then(function (response) {
 603                 successCallbackFunction(response.data);
 604             })["catch"]
 605             (UtilityService.runHttpErrorHandler);
 606         },
 607
 608         getServiceModels: function (globalCustomerId, serviceType, successCallbackFunction) {
 609             $log
 610                 .debug("AaiService:getServices");
 611             var url = COMPONENT.AAI_GET_SERVICES + COMPONENT.FORWARD_SLASH + globalCustomerId + COMPONENT.FORWARD_SLASH + serviceType + COMPONENT.ASSIGN + Math.random();
 612
 613             $http.get(url,
 614                 {
 615                     timeout: PropertyService
 616                         .getServerResponseTimeoutMsec()
 617                 }).then(function (response) {
 618                 if (response.data) {
 619                     successCallbackFunction(response);
 620                 } else {
 621                     successCallbackFunction([]);
 622                 }
 623             })["catch"]
 624             (UtilityService.runHttpErrorHandler);
 625         },
 626         getServiceModelsByServiceType: function (namedQueryId, globalCustomerId, serviceType, successCallbackFunction) {
 627             $log
 628                 .debug("AaiService:getServiceModelsByServiceType");
 629             var url = COMPONENT.AAI_GET_SERVICES_BY_TYPE + COMPONENT.FORWARD_SLASH + namedQueryId + COMPONENT.FORWARD_SLASH + globalCustomerId + COMPONENT.FORWARD_SLASH + serviceType + COMPONENT.ASSIGN + Math.random();
 630
 631             $http.get(url,
 632                 {
 633                     timeout: PropertyService
 634                         .getServerResponseTimeoutMsec()
 635                 }).then(function (response) {
 636                 if (response.data) {
 637                     successCallbackFunction(response);
 638                 } else {
 639                     successCallbackFunction([]);
 640                 }
 641             })["catch"]
 642             (UtilityService.runHttpErrorHandler);
 643         },
 644
 645         getVnfsByCustomerIdAndServiceType: function (globalSubscriberId, serviceType, nfRole, cloudRegion) {
 646             let deferred = $q.defer();
 647
 648             let url = globalSubscriberId + COMPONENT.FORWARD_SLASH + serviceType
 649
 650             const path = COMPONENT.AAI_GET_VNF_BY_CUSTOMERID_AND_SERVICETYPE + url;
 651             let config = getConfigParams(nfRole, cloudRegion);
 652
 653             if (UtilityService.hasContents(globalSubscriberId) &&
 654                 UtilityService.hasContents(serviceType)) {
 655
 656                 $http.get(path, config)
 657                     .success(function (response) {
 658                         if (response) {
 659                             deferred.resolve({data: response});
 660                         } else {
 661                             deferred.resolve({data: []});
 662                         }
 663                     }).error(function (data, status, headers, config) {
 664                     deferred.reject({message: data, status: status});
 665                 });
 666             }
 667
 668             return deferred.promise;
 669         },
 670
 671         getVnfVersionsByInvariantId: function (modelInvariantId) {
 672             var deferred = $q.defer();
 673
 674             if (UtilityService.hasContents(modelInvariantId)) {
 675                 var body = {"versions": modelInvariantId};
 676                 $http.post((COMPONENT.AAI_GET_VERSION_BY_INVARIANT_ID), body)
 677
 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
 693         getSubscriberServiceTypes: function (subscriberUuid) {
 694             var deferred = $q.defer();
 695             $log.debug("AaiService:getSubscriberServiceTypes: subscriberUuid: " + subscriberUuid);
 696
 697             if (UtilityService.hasContents(subscriberUuid)) {
 698                 $http.get(COMPONENT.AAI_SUB_DETAILS_PATH + subscriberUuid + COMPONENT.ASSIGN + Math.random())
 699                     .success(function (response) {
 700                         if (response && [FIELD.ID.SERVICE_SUBSCRIPTIONS]) {
 701                             deferred.resolve({data: response[FIELD.ID.SERVICE_SUBSCRIPTIONS][FIELD.ID.SERVICE_SUBSCRIPTION]});
 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         getVnfInstancesList: function (globalSubscriberId, serviceType, modelVersionId, modelInvariantId, cloudRegionId) {
 713             var deferred = $q.defer();
 714             $http.get([COMPONENT.AAI_GET_VNF_INSTANCES_LIST,
 715                 globalSubscriberId,
 716                 serviceType,
 717                 modelVersionId,
 718                 modelInvariantId,
 719                 cloudRegionId]
 720                 .join(COMPONENT.FORWARD_SLASH))
 721                 .success(function (response) {
 722                     deferred.resolve(response);
 723                 }).error(function (data, status) {
 724                 deferred.reject({message: data, status: status});
 725             });
 726             return deferred.promise;
 727         },
 728         getPnfInstancesList: function (globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegionId, equipVendor, equipModel) {
 729             var deferred = $q.defer();
 730             $http.get([COMPONENT.AAI_GET_PNF_INSTANCES_LIST,
 731                 globalCustomerId, serviceType,
 732                 modelVersionId, modelInvariantId,
 733                 cloudRegionId,
 734                 equipVendor, equipModel
 735             ].join(COMPONENT.FORWARD_SLASH))
 736                 .success(function (response) {
 737                     deferred.resolve(response);
 738                 }).error(function (data, status) {
 739                 deferred.reject({message: data, status: status});
 740             });
 741             return deferred.promise;
 742         },
 743         getByUri: function (uri) {
 744             var deferred = $q.defer();
 745
 746             $http.get(COMPONENT.AAI_GET_BY_URI + uri)
 747                 .success(function (response) {
 748                     deferred.resolve({data: []});
 749                 }).error(function (data, status, headers, config) {
 750                 deferred.reject({message: data, status: status});
 751             });
 752
 753             return deferred.promise;
 754         },
 755         getConfiguration: function (configurationId) {
 756             var deferred = $q.defer();
 757
 758             $http.get(COMPONENT.AAI_GET_CONFIGURATION + configurationId)
 759                 .success(function (response) {
 760                     deferred.resolve({data: []});
 761                 }).error(function (data, status, headers, config) {
 762                 deferred.reject({message: data, status: status});
 763             });
 764
 765             return deferred.promise;
 766         },
 767
 768         getInstanceGroupsByVNFInstanceId: function (vnf_instance_id, successCallback, errorCallback) {
 769             var url = COMPONENT.AAI_GET_INSTANCE_GROUPS_BY_VNF_INSTANCE_ID_PATH + "/" + vnf_instance_id;
 770
 771             $http.get(url, {}, {
 772                 timeout: PropertyService.getServerResponseTimeoutMsec()
 773             }).then(function (response) {
 774                 successCallback(response);
 775             }, function (response) {
 776                 errorCallback(response);
 777             });
 778         },
 779
 780         postPOMBAverificationRequest: function (url, data, config) {
 781             $http.post(url, data, config)
 782                 .success(function (data, status, headers, config) {
 783                     //If at some point in the future the result should be handled - this should be the entry point.
 784                     log.debug("POMBA was called successfully with data: " + data);
 785                 })
 786                 .error(function (data, status, header, config) {
 787                     log.debug("Error: " +
 788                         "Data: " + data +
 789                         "status: " + status +
 790                         "headers: " + header +
 791                         "config: " + config);
 792                 });
 793         },
 794
 795         cloudRegionOptionId: function (cloudOwner, cloudRegionId) {
 796             return ('option-' + cloudOwner + '-' + cloudRegionId).toLowerCase();
 797         },
 798
 799         getHomingData: function (vnfInstanceId, vfModuleId) {
 800             let self = this;
 801             var url = COMPONENT.AAI_GET_HOMING_DATA.replace('@vnfInstanceId', vnfInstanceId)
 802                 .replace('@vfModuleId', vfModuleId);
 803
 804             var deferred = $q.defer();
 805
 806             $http.get(url)
 807                 .success(function (response) {
 808                     var cloudOwner = response[COMPONENT.CLOUD_OWNER];
 809                     var cloudRegionId = response[COMPONENT.CLOUD_REGION_ID];
 810                     if (cloudOwner && cloudRegionId) {
 811                         response["cloudRegionOptionId"] = self.cloudRegionOptionId(cloudOwner, cloudRegionId);
 812                     } else {
 813                         response["cloudRegionOptionId"] = null;
 814                     }
 815
 816                     deferred.resolve({data: response});
 817                 }).error(function (data, status, headers, config) {
 818                 deferred.reject({message: data, status: status});
 819             });
 820
 821             return deferred.promise;
 822
 823         },
 824
 825         removeVendorFromCloudOwner: function (cloudOwner) {
 826             // Handle the case where cloud owner is formatted
 827             // like "{vendor}-{cloud-name}"
 828             return cloudOwner.trim().replace(/^[^-]*-/, '');
 829         }
 830     };
 831 };
 832
 833 appDS2.factory("AaiService", ["$http", "$log", "PropertyService",
 834     "UtilityService", "COMPONENT", "FIELD", "$q", "featureFlags", AaiService]);