vid-app-common/src/main/webapp/app/vid/scripts/controller/InstantiationController.js

   1 /*-\r
   2  * ============LICENSE_START=======================================================\r
   3  * VID\r
   4  * ================================================================================\r
   5  * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.\r
   6  * Modifications Copyright (C) 2019 IBM.\r
   7  * ================================================================================\r
   8  * Licensed under the Apache License, Version 2.0 (the "License");\r
   9  * you may not use this file except in compliance with the License.\r
  10  * You may obtain a copy of the License at\r
  11  * \r
  12  *      http://www.apache.org/licenses/LICENSE-2.0\r
  13  * \r
  14  * Unless required by applicable law or agreed to in writing, software\r
  15  * distributed under the License is distributed on an "AS IS" BASIS,\r
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  17  * See the License for the specific language governing permissions and\r
  18  * limitations under the License.\r
  19  * ============LICENSE_END=========================================================\r
  20  */\r
  21 \r
  22 /**\r
  23  * The Instantiation (or View/Edit) Controller controls the instantiation/removal of\r
  24  * deployable objects (Services, VNFs, VF-Modules, Networks, and Volume-Groups)\r
  25  */\r
  26 (function () {\r
  27     "use strict";\r
  28 \r
  29     appDS2.requires.push('ui.tree');\r
  30 \r
  31     appDS2.controller("InstantiationController", function ($scope, $route, $location, $timeout, $uibModal, COMPONENT, VIDCONFIGURATION, FIELD, DataService, PropertyService, UtilityService, VnfService, $http, vidService, AaiService, PnfService, CrService, AsdcService, $q, featureFlags, _, CreationService, $window, DeleteResumeService) {\r
  32         $scope.popup = new Object();\r
  33         $scope.defaultBaseUrl = "";\r
  34         $scope.responseTimeoutMsec = 60000;\r
  35         $scope.properties = UtilityService.getProperties();\r
  36         $scope.resumeStatus = COMPONENT.RESUME_STATUS;\r
  37         //isPermitted - returned as string from url and converted into boolean\r
  38         $scope.isPermitted = $location.search().isPermitted == "true";\r
  39         $scope.STATUS_CONSTANTS = FIELD.STATUS;\r
  40         $scope.pnfs = [];// PNF data init;\r
  41         $scope.collectionResource = {};\r
  42         $scope.collections = [];\r
  43         $scope.networks = [];\r
  44         $scope.isCR = false;\r
  45         $scope.isVFC = false;\r
  46         $scope.init = function () {\r
  47             /*\r
  48              * These 2 statements should be included in non-test code.\r
  49              */\r
  50             // takes a default value, retrieves the prop value from the file system and sets it\r
  51             var msecs = PropertyService.retrieveMsoMaxPollingIntervalMsec();\r
  52             PropertyService.setMsoMaxPollingIntervalMsec(msecs);\r
  53 \r
  54             // takes a default value, retrieves the prop value from the file system and sets it\r
  55             var polls = PropertyService.retrieveMsoMaxPolls();\r
  56             PropertyService.setMsoMaxPolls(polls);\r
  57         };\r
  58 \r
  59 \r
  60         $scope.convertModel = function (asdcModel) {\r
  61             if (!asdcModel) return undefined;\r
  62             var convertedAsdcModel = UtilityService.convertModel(asdcModel);\r
  63             return convertedAsdcModel;\r
  64         };\r
  65 \r
  66         $scope.prepareScopeWithModel = function () {\r
  67             // skip if no model\r
  68             if (!vidService.getModel()) return;\r
  69 \r
  70             $scope.service = {\r
  71                 "model": vidService.getModel(),\r
  72                 "convertedModel": $scope.convertModel(vidService.getModel()),\r
  73                 "instance": vidService.getInstance()\r
  74             };\r
  75 \r
  76 \r
  77             $scope.isCR = !_.isEmpty($scope.service.model.collectionResources);\r
  78             if ($scope.isCR)\r
  79                 prepareCr();\r
  80             else\r
  81                 preparePnfs();\r
  82         };\r
  83 \r
  84         function preparePnfs() {\r
  85             var serviceInstance = {\r
  86                 globalCustomerId: $location.search().subscriberId,\r
  87                 serviceType: $location.search().serviceType,\r
  88                 serviceInstanceId: $location.search().serviceInstanceId\r
  89             };\r
  90 \r
  91             _setPnf(serviceInstance).then(function (data) {\r
  92                 $scope.pnfs = data;\r
  93             });\r
  94         }\r
  95 \r
  96 \r
  97         function prepareCr() {\r
  98             var serviceInstance = {\r
  99                 globalCustomerId: $location.search().subscriberId,\r
 100                 serviceType: $location.search().serviceType,\r
 101                 serviceInstanceId: $location.search().serviceInstanceId\r
 102             };\r
 103 \r
 104             _setCr(serviceInstance).then(function (data) {\r
 105                 $scope.collectionResource = data;\r
 106                 $scope.collections.push($scope.collectionResource.collection);\r
 107                 $scope.networks.push($scope.collectionResource.networks[0]);\r
 108             });\r
 109         }\r
 110 \r
 111         $scope.returnVfModules = function (vnfInstance) {\r
 112 \r
 113             var svcModel = $scope.service.convertedModel;\r
 114             //var vnfModelInvariantUuid = vnfInstance[FIELD.ID.MODEL_INVAR_ID];\r
 115             var vnfModelVersionId = vnfInstance[FIELD.ID.MODEL_VERSION_ID]; // model uuid\r
 116             var vnfModelCustomizationUuid = vnfInstance[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 117 \r
 118             var vnfModel = null;\r
 119 \r
 120             if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {\r
 121                 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {\r
 122                     vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];\r
 123                     if (vnfModel !== undefined) {\r
 124                         if (!($scope.isObjectEmpty(vnfModel.vfModules))) {\r
 125                             //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.vfModules, null, 4));\r
 126                             return (vnfModel.vfModules);\r
 127                         }\r
 128                     }\r
 129                 }\r
 130                 else {\r
 131                     // old flow\r
 132                     if (vnfModelVersionId != null) {\r
 133                         vnfModel = svcModel.vnfs[vnfModelVersionId];\r
 134                         if (vnfModel !== undefined) {\r
 135                             if (!($scope.isObjectEmpty(vnfModel.vfModules))) {\r
 136                                 //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.vfModules, null, 4));\r
 137                                 return (vnfModel.vfModules);\r
 138                             }\r
 139                         }\r
 140                     }\r
 141                 }\r
 142 \r
 143             }\r
 144             return null;\r
 145         };\r
 146         $scope.hasVfModules = function (vnfInstance) {\r
 147             if ($scope.returnVfModules(vnfInstance) != null) {\r
 148                 return true;\r
 149             }\r
 150             return false;\r
 151         };\r
 152         $scope.returnVolumeGroups = function (vnfInstance) {\r
 153 \r
 154             var svcModel = $scope.service.convertedModel;\r
 155 \r
 156             //var vnfModelInvariantUuid = vnfInstance[FIELD.ID.MODEL_INVAR_ID];\r
 157             var vnfModelVersionId = vnfInstance[FIELD.ID.MODEL_VERSION_ID];\r
 158             var vnfModelCustomizationUuid = vnfInstance[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 159 \r
 160             var vnfModel = null;\r
 161 \r
 162             if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {\r
 163                 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {\r
 164                     vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];\r
 165                     if (vnfModel !== undefined) {\r
 166 \r
 167                         if (!($scope.isObjectEmpty(vnfModel.volumeGroups))) {\r
 168                             //console.log ("vnfModel.volumeGroups: "); console.log (JSON.stringify(vnfModel.volumeGroups, null, 4));\r
 169                             return (vnfModel.volumeGroups);\r
 170                         }\r
 171                     }\r
 172                 }\r
 173                 else {\r
 174                     // old flow\r
 175                     if (vnfModelVersionId != null) {\r
 176                         vnfModel = svcModel.vnfs[vnfModelVersionId];\r
 177                         if (!($scope.isObjectEmpty(vnfModel.volumeGroups))) {\r
 178                             //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.volumeGroups, null, 4));\r
 179                             return (vnfModel.volumeGroups);\r
 180                         }\r
 181                     }\r
 182                 }\r
 183 \r
 184             }\r
 185             return null;\r
 186         };\r
 187         $scope.hasVolumeGroups = function (vnfInstance) {\r
 188             if ($scope.returnVolumeGroups(vnfInstance) != null) {\r
 189                 return true;\r
 190             }\r
 191             return false;\r
 192         };\r
 193         $scope.deleteNetwork = function (serviceObject, network) {\r
 194 \r
 195             console.log("Removing Network " + network.name);\r
 196 \r
 197             //Send delete network request to MSO\r
 198 \r
 199             //var networks = this.service.instance.networks;\r
 200 \r
 201             //networks.splice(networks.indexOf(network), 1);\r
 202 \r
 203             //Retrieve updated data from A&AI\r
 204             var serviceInstance = serviceObject.object;\r
 205 \r
 206             setCurrentNetworkModelInfoFromScope(network);\r
 207 \r
 208             DataService.setInventoryItem(network.object);\r
 209 \r
 210             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
 211             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 212             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 213 \r
 214             DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);\r
 215             DataService.setServiceInstanceName($scope.service.instance.name);\r
 216             DataService.setServiceName($scope.service.model.service.name);\r
 217             DataService.setServiceUuid($scope.service.model.service.uuid);\r
 218             DataService.setNetworkInstanceId(network.object[FIELD.ID.NETWORK_ID]);\r
 219 \r
 220             $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {\r
 221                 componentId: COMPONENT.NETWORK,\r
 222                 callbackFunction: deleteOrResumeCallback,\r
 223                 dialogMethod: COMPONENT.DELETE\r
 224             });\r
 225         };\r
 226 \r
 227         $scope.allowTransferToNewScreenAndShowButton = function (){\r
 228           if(featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_FLASH_REPLACE_VF_MODULE)) {\r
 229               return $scope.isPermitted && !($scope.isMacro());\r
 230           }\r
 231           return false;\r
 232         };\r
 233 \r
 234         $scope.deleteService = function (serviceObject, serviceOrchestrationStatus) {\r
 235 \r
 236             var serviceInstance = serviceObject.object;\r
 237 \r
 238             console.log("Removing Service " + $scope.service.instance.name);\r
 239 \r
 240             if ($scope.isMacro()) {\r
 241                 DataService.setALaCarte(false);\r
 242             }\r
 243             else {\r
 244                 DataService.setALaCarte(true);\r
 245             }\r
 246             DataService.setMacro($scope.isMacro());\r
 247             DataService.setInventoryItem(serviceInstance);\r
 248             setCurrentServiceModelInfoFromScope();\r
 249 \r
 250 \r
 251             DataService.setSubscriberName(serviceObject[FIELD.ID.SUBSCRIBER_NAME]);\r
 252             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 253             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 254 \r
 255             DataService.setGlobalCustomerId(serviceObject[COMPONENT.GLOBAL_CUSTOMER_ID]);\r
 256             DataService.setServiceInstanceName($scope.service.instance.name);\r
 257 \r
 258             DataService.setServiceName($scope.service.model.service.name);\r
 259 \r
 260             DataService.setServiceUuid($scope.service.model.service.uuid);\r
 261 \r
 262             $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {\r
 263                 componentId: COMPONENT.SERVICE,\r
 264                 callbackFunction: deleteServiceInstanceCallbackFunction,\r
 265                 dialogMethod: COMPONENT.DELETE,\r
 266                 serviceStatus: serviceOrchestrationStatus\r
 267             });\r
 268 \r
 269         };\r
 270 \r
 271         function populate_popup_vfModule(serviceObject, vfModule, vnf) {\r
 272             var serviceInstance = serviceObject.object;\r
 273 \r
 274             DataService.setInventoryItem(vfModule.object);\r
 275 \r
 276             setCurrentVfModuleModelInfoFromScope(vnf, vfModule);\r
 277             var vfModuleInstanceID = vfModule.object[FIELD.ID.VF_MODULE_ID];\r
 278             if (vfModuleInstanceID == null) {\r
 279                 vfModuleInstanceID = "";\r
 280             }\r
 281 \r
 282             DataService.setVnfInstanceId(vnf.object[FIELD.ID.VNF_ID]);\r
 283             DataService.setVfModuleInstanceId(vfModuleInstanceID);\r
 284 \r
 285             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
 286             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 287             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 288 \r
 289             DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);\r
 290             DataService.setServiceInstanceName($scope.service.instance.name);\r
 291 \r
 292             DataService.setServiceName($scope.service.model.service.name);\r
 293 \r
 294             DataService.setServiceUuid($scope.service.model.service.uuid);\r
 295         }\r
 296 \r
 297         var modalInstance;\r
 298 \r
 299         var openMsoModal = function (msoType, requestParams, callbackFunction, configuration) {\r
 300              modalInstance = $uibModal.open({\r
 301                 templateUrl: 'app/vid/scripts/modals/mso-commit/mso-commit.html',\r
 302                 controller: "msoCommitModalController",\r
 303                 backdrop: false,\r
 304                 resolve: {\r
 305                     msoType: function () {\r
 306                         return msoType;\r
 307                     },\r
 308                     requestParams: function () {\r
 309                         requestParams.callbackFunction = callbackFunction;\r
 310                         return requestParams;\r
 311                     },\r
 312                     configuration: function () {\r
 313                         return configuration;\r
 314                     }\r
 315                 }\r
 316             });\r
 317         };\r
 318 \r
 319         var openVfModuleWithHomingDataModal = function(action, vfModule)  {\r
 320             modalInstance = $uibModal.open({\r
 321                 controller: 'vfModuleActionModalController',\r
 322                 templateUrl: 'app/vid/scripts/modals/vf-module-homing-data-action/vf-module-homing-data-action.html',\r
 323                 backdrop: false,\r
 324                 resolve: {\r
 325                     action: function () {\r
 326                         return action;\r
 327                     },\r
 328                     vfModule: function() {\r
 329                         return vfModule;\r
 330                     }\r
 331                 }\r
 332             });\r
 333 \r
 334             modalInstance.result.then(function (data) {\r
 335                 if (data.msoType && data.requestParams) {\r
 336                     openMsoModal(data.msoType, data.requestParams, deleteOrResumeCallback, null);\r
 337                 }\r
 338             });\r
 339         };\r
 340 \r
 341         function getLcpCloudRegionTenantList() {\r
 342             AaiService.getLcpCloudRegionTenantList(DataService\r
 343                 .getGlobalCustomerId(), DataService.getServiceType(), function(\r
 344                 response) {\r
 345                 $scope.lcpAndTenant = response;\r
 346                 $scope.isFeatureFlagCloudOwner = featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST);\r
 347                 $scope.lcpRegionList = _.uniqBy(response, 'cloudRegionId');\r
 348             });\r
 349         }\r
 350 \r
 351         $scope.deleteVfModule = function (serviceObject, vfModule, vnf) {\r
 352             $scope.isSoftDeleteEnabled = true;\r
 353 \r
 354             populate_popup_vfModule(serviceObject, vfModule, vnf);\r
 355 \r
 356             if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_SOFT_DELETE_ALACARTE_VF_MODULE))  {\r
 357 \r
 358                 if (DataService.getLoggedInUserId())  {\r
 359                     openVfModuleWithHomingDataModal(COMPONENT.DELETE, vfModule);\r
 360                 }\r
 361                 else {\r
 362                     AaiService.getLoggedInUserID(function (response) {\r
 363                         var userID = response.data;\r
 364                         DataService.setLoggedInUserId(userID);\r
 365                         openVfModuleWithHomingDataModal(COMPONENT.DELETE, vfModule);\r
 366                     });\r
 367                 }\r
 368             }\r
 369             else {\r
 370                 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {\r
 371                     componentId: COMPONENT.VF_MODULE,\r
 372                     callbackFunction: deleteOrResumeCallback,\r
 373                     dialogMethod: COMPONENT.DELETE\r
 374                 });\r
 375             }\r
 376             console.log("Removing VF-Module", vfModule);\r
 377         };\r
 378 \r
 379         function setCurrentServiceModelInfoFromScope() {\r
 380             DataService.setModelInfo(COMPONENT.SERVICE, {\r
 381                 "modelInvariantId": $scope.service.model.service.invariantUuid,\r
 382                 "modelVersion": $scope.service.model.service.version,\r
 383                 "modelNameVersionId": $scope.service.model.service.uuid,\r
 384                 "modelName": $scope.service.model.service.name,\r
 385                 "inputs": ""\r
 386             });\r
 387         };\r
 388 \r
 389         function setCurrentVNFModelInfo(vnf) {\r
 390             var svcModel = $scope.service.convertedModel;\r
 391             var vnfModel;\r
 392             var vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 393             var vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];\r
 394             if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {\r
 395                 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {\r
 396                     vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];\r
 397                 }\r
 398                 else {\r
 399                     vnfModel = svcModel.vnfs[vnfModelVersionId];\r
 400                 }\r
 401                 if (!($scope.isObjectEmpty(vnfModel))) {\r
 402 \r
 403                     DataService.setModelInfo(COMPONENT.VNF, {\r
 404                         "modelInvariantId": vnfModel.invariantUuid,\r
 405                         "modelVersion": vnfModel.version,\r
 406                         "modelNameVersionId": vnfModel.uuid,\r
 407                         "modelCustomizationName": vnfModel.modelCustomizationName,\r
 408                         "customizationUuid": vnfModel.customizationUuid,\r
 409                         "modelName": vnfModel.name,\r
 410                         "inputs": ""\r
 411                     });\r
 412                 }\r
 413             }\r
 414 \r
 415 \r
 416         }\r
 417 \r
 418         function setCurrentNetworkModelInfoFromScope(network) {\r
 419             var svcModel = $scope.service.convertedModel;\r
 420             var netModel;\r
 421             // set model default and override later if found\r
 422             DataService.setModelInfo(COMPONENT.NETWORK, {});\r
 423 \r
 424             if (network.object != null) {\r
 425 \r
 426                 //var netModelInvariantUuid = network.object[FIELD.ID.MODEL_INVAR_ID];\r
 427                 var netModelVersionId = network.object[FIELD.ID.MODEL_VERSION_ID]; // model uuid\r
 428                 var netModelCustomizationUuid = network.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 429 \r
 430                 if (UtilityService.hasContents(netModelCustomizationUuid)) {\r
 431                     // set it to what came from a&ai\r
 432                     DataService.setResCustomizationUuid(netModelCustomizationUuid);\r
 433                 }\r
 434 \r
 435                 if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.networks)))) {\r
 436                     if ((svcModel.isNewFlow) && (UtilityService.hasContents(netModelCustomizationUuid))) {\r
 437                         netModel = svcModel.networks[netModelCustomizationUuid];\r
 438                     }\r
 439                     else {\r
 440 \r
 441                         if (UtilityService.hasContents(netModelVersionId)) {\r
 442                             netModel = svcModel.networks[netModelVersionId];\r
 443                         }\r
 444 \r
 445                     }\r
 446                 }\r
 447             }\r
 448             if (!($scope.isObjectEmpty(netModel))) {\r
 449                 DataService.setModelInfo(COMPONENT.NETWORK, {\r
 450                     "modelInvariantId": netModel.invariantUuid,\r
 451                     "modelVersion": netModel.version,\r
 452                     "modelNameVersionId": netModel.uuid,\r
 453                     "modelCustomizationName": netModel.modelCustomizationName,\r
 454                     "customizationUuid": netModel.customizationUuid,\r
 455                     "modelName": netModel.name,\r
 456                     "inputs": ""\r
 457                 });\r
 458             }\r
 459         }\r
 460 \r
 461         function setCurrentVfModuleModelInfoFromScope(vnf, vfModule) {\r
 462 \r
 463             var svcModel = $scope.service.convertedModel;\r
 464 \r
 465             //var vnfModelInvariantUuid = vnf.object[FIELD.ID.MODEL_INVAR_ID];\r
 466             var vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];\r
 467             var vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 468             var vnfModel = null;\r
 469             var vfModuleModel = null;\r
 470 \r
 471             DataService.setModelInfo(COMPONENT.VF_MODULE, {\r
 472                 "modelInvariantId": "",\r
 473                 "modelVersion": "",\r
 474                 "modelNameVersionId": "",\r
 475                 "modelCustomizationName": "",\r
 476                 "customizationUuid": "",\r
 477                 "modelName": "",\r
 478                 "inputs": ""\r
 479             });\r
 480 \r
 481             if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {\r
 482                 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {\r
 483                     vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];\r
 484 \r
 485                     var vfModuleCustomizationUuid = vfModule.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 486                     if (!($scope.isObjectEmpty(vnfModel)) && !($scope.isObjectEmpty(vnfModel.vfModules)) && UtilityService.hasContents(vfModuleCustomizationUuid)) {\r
 487 \r
 488                         vfModuleModel = vnfModel.vfModules[vfModuleCustomizationUuid];\r
 489 \r
 490                     }\r
 491                 }\r
 492                 else {\r
 493                     // old flow\r
 494                     if (vnfModelVersionId != null) {\r
 495                         vnfModel = svcModel.vnfs[vnfModelVersionId];\r
 496                     }\r
 497                     //var vfModuleInvariantUuid = vfModule.object[FIELD.ID.MODEL_INVAR_ID];\r
 498                     var vfModuleModelVersionId = vfModule.object[FIELD.ID.MODEL_VERSION_ID];\r
 499                     if ((!($scope.isObjectEmpty(vnfModel))) && (!($scope.isObjectEmpty(vnfModel.vfModules))) &&\r
 500                         UtilityService.hasContents(vfModuleModelVersionId)) {\r
 501                         vfModuleModel = vnfModel.vfModules[vfModuleModelVersionId];\r
 502                     }\r
 503                 }\r
 504                 if (!($scope.isObjectEmpty(vfModuleModel))) {\r
 505                     DataService.setModelInfo(COMPONENT.VF_MODULE, {\r
 506                         "modelInvariantId": vfModuleModel.invariantUuid,\r
 507                         "modelVersion": vfModuleModel.version,\r
 508                         "modelNameVersionId": vfModuleModel.uuid,\r
 509                         "modelCustomizationName": vfModuleModel.modelCustomizationName,\r
 510                         "customizationUuid": vfModuleModel.customizationUuid,\r
 511                         "modelName": vfModuleModel.name,\r
 512                         "inputs": ""\r
 513                     });\r
 514                 }\r
 515             }\r
 516         }\r
 517 \r
 518         function setCurrentVolumeGroupModelInfoFromScope(vnf, vfModule) {\r
 519             var svcModel = $scope.service.convertedModel;\r
 520 \r
 521             var vnfModelCustomizationUuid = null;\r
 522             var vnfModel = null;\r
 523             var vnfModelVersionId = null;\r
 524 \r
 525             vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];\r
 526             vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 527 \r
 528             DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {\r
 529                 "modelInvariantId": "",\r
 530                 "modelVersion": "",\r
 531                 "modelNameVersionId": "",\r
 532                 "modelCustomizationName": "",\r
 533                 "customizationUuid": "",\r
 534                 "modelName": "",\r
 535                 "inputs": ""\r
 536             });\r
 537 \r
 538             if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {\r
 539                 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {\r
 540                     vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];\r
 541                 }\r
 542                 else {\r
 543                     vnfModel = svcModel.vnfs[vnfModelVersionId];\r
 544                 }\r
 545             }\r
 546 \r
 547 \r
 548             // volume groups don't have model-invariant-id/version in a&ai.\r
 549             // Their model-invariant-id/version is the one for the associated vfModule\r
 550 \r
 551             var vfModuleModelVersionId = vfModule.object[FIELD.ID.MODEL_VERSION_ID];\r
 552             var vfModuleCustomizationUuid = vfModule.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 553             var volGroupModel = null;\r
 554 \r
 555             if (!($scope.isObjectEmpty(vnfModel)) && !($scope.isObjectEmpty(vnfModel.volumeGroups))) {\r
 556                 if ((svcModel.isNewFlow) && (UtilityService.hasContents(vfModuleCustomizationUuid))) {\r
 557                     volGroupModel = vnfModel.volumeGroups[vfModuleCustomizationUuid];\r
 558                 }\r
 559                 else {\r
 560                     volGroupModel = vnfModel.volumeGroups[vfModuleModelVersionId];\r
 561                 }\r
 562                 if (!($scope.isObjectEmpty(volGroupModel))) {\r
 563                     DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {\r
 564                         "modelInvariantId": volGroupModel.invariantUuid,\r
 565                         "modelVersion": volGroupModel.version,\r
 566                         "modelNameVersionId": volGroupModel.uuid,\r
 567                         "modelCustomizationName": volGroupModel.modelCustomizationName,\r
 568                         "customizationUuid": volGroupModel.customizationUuid,\r
 569                         "modelName": volGroupModel.name,\r
 570                         "inputs": ""\r
 571                     });\r
 572 \r
 573                 }\r
 574             }\r
 575         }\r
 576 \r
 577         function setCurrentVolumeGroupModelInfoByVfModuleFromScope(vnf, volumeGroup) {\r
 578             var svcModel = $scope.service.convertedModel;\r
 579 \r
 580             var vnfModelCustomizationUuid = null;\r
 581             var vnfModel = null;\r
 582             var vnfModelVersionId = null;\r
 583 \r
 584             vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];\r
 585             vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 586 \r
 587             DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {\r
 588                 "modelInvariantId": "",\r
 589                 "modelVersion": "",\r
 590                 "modelNameVersionId": "",\r
 591                 "modelCustomizationName": "",\r
 592                 "customizationUuid": "",\r
 593                 "modelName": "",\r
 594                 "inputs": ""\r
 595             });\r
 596 \r
 597             if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {\r
 598                 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {\r
 599                     vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];\r
 600                 }\r
 601                 else {\r
 602                     vnfModel = svcModel.vnfs[vnfModelVersionId];\r
 603                 }\r
 604             }\r
 605 \r
 606 \r
 607             // volume groups don't have model-invariant-id/version in a&ai.\r
 608             // Their model-invariant-id/version is the one for the associated vfModule\r
 609 \r
 610             var vfModuleModelVersionId = volumeGroup.object[FIELD.ID.VF_MODULE_MODEL_VERSION_ID];\r
 611             var vfModuleCustomizationUuid = volumeGroup.object[FIELD.ID.VF_MODULE_MODEL_CUSTOMIZATION_ID];\r
 612             var volGroupModel = null;\r
 613             if ((!($scope.isObjectEmpty(vnfModel))) && (!($scope.isObjectEmpty(vnfModel.volumeGroups)))) {\r
 614                 if ((svcModel.isNewFlow) && (UtilityService.hasContents(vfModuleCustomizationUuid))) {\r
 615                     volGroupModel = vnfModel.volumeGroups[vfModuleCustomizationUuid];\r
 616                 }\r
 617                 else {\r
 618                     volGroupModel = vnfModel.volumeGroups[vfModuleModelVersionId];\r
 619                 }\r
 620                 if (!($scope.isObjectEmpty(volGroupModel))) {\r
 621                     DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {\r
 622                         "modelInvariantId": volGroupModel.invariantUuid,\r
 623                         "modelVersion": volGroupModel.version,\r
 624                         "modelNameVersionId": volGroupModel.uuid,\r
 625                         "modelCustomizationName": volGroupModel.modelCustomizationName,\r
 626                         "customizationUuid": volGroupModel.customizationUuid,\r
 627                         "modelName": volGroupModel.name,\r
 628                         "inputs": ""\r
 629                     });\r
 630 \r
 631                 }\r
 632             }\r
 633         }\r
 634 \r
 635         $scope.deleteVnf = function (serviceObject, vnf) {\r
 636             console.log("Removing VNF " + vnf.name);\r
 637 \r
 638             var serviceInstance = serviceObject.object;\r
 639             var svcModel = $scope.service.convertedModel;\r
 640             DataService.setInventoryItem(vnf.object);\r
 641 \r
 642             /*var vnftype = vnf.object['vnf-type'];\r
 643             if (vnftype == null)\r
 644                 vnftype = "";\r
 645             else\r
 646             {\r
 647                 var n = vnftype.search("/");\r
 648                 if (n >= 0)\r
 649                     vnftype = vnftype.substring(n+1);\r
 650             }*/\r
 651 \r
 652             var svcModel = $scope.service.convertedModel;\r
 653             var vnfModelInvariantUuid = null;\r
 654             var vnfModelVersion = null;\r
 655             var vnfModelCustomizationUuid = null;\r
 656             var vnfModel = null;\r
 657             var vnfModelVersionId = null;\r
 658 \r
 659             vnfModelInvariantUuid = vnf.object[FIELD.ID.MODEL_INVAR_ID];\r
 660             vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];\r
 661             vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 662 \r
 663             DataService.setModelInfo(COMPONENT.VNF, {\r
 664                 "modelInvariantId": vnfModelInvariantUuid,\r
 665                 "modelVersion": "",\r
 666                 "modelNameVersionId": vnfModelVersionId,\r
 667                 "modelCustomizationName": "",\r
 668                 "customizationUuid": vnfModelCustomizationUuid,\r
 669                 "modelName": "",\r
 670                 "inputs": ""\r
 671             });\r
 672 \r
 673             if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {\r
 674                 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {\r
 675                     vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];\r
 676                 }\r
 677                 else {\r
 678                     vnfModel = svcModel.vnfs[vnfModelVersionId];\r
 679                 }\r
 680                 //console.log ( "vnf models: "); console.log ( JSON.stringify ($scope.service.convertedModel.vnfs, null, 4) );\r
 681                 if (!($scope.isObjectEmpty(vnfModel))) {\r
 682 \r
 683                     DataService.setModelInfo(COMPONENT.VNF, {\r
 684                         "modelInvariantId": vnfModel.invariantUuid,\r
 685                         "modelVersion": vnfModel.version,\r
 686                         "modelNameVersionId": vnfModel.uuid,\r
 687                         "modelCustomizationName": vnfModel.modelCustomizationName,\r
 688                         "customizationUuid": vnfModel.customizationUuid,\r
 689                         "modelName": vnfModel.name,\r
 690                         "inputs": ""\r
 691                     });\r
 692                 }\r
 693             }\r
 694 \r
 695             DataService.setVnfInstanceId(vnf.object[FIELD.ID.VNF_ID]);\r
 696 \r
 697             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
 698             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 699             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 700 \r
 701             DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);\r
 702             DataService.setServiceInstanceName($scope.service.instance.name);\r
 703 \r
 704             DataService.setServiceName($scope.service.model.service.name);\r
 705 \r
 706             DataService.setServiceUuid($scope.service.model.service.uuid);\r
 707 \r
 708             $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {\r
 709                 componentId: COMPONENT.VNF,\r
 710                 callbackFunction: deleteOrResumeCallback,\r
 711                 dialogMethod: COMPONENT.DELETE\r
 712             });\r
 713 \r
 714         };\r
 715 \r
 716         $scope.deleteVolumeGroup = function (serviceObject, vnf, vfModule, volumeGroup) {\r
 717 \r
 718             console.log("Removing Volume Group " + volumeGroup.name);\r
 719             var haveModel = false;\r
 720 \r
 721             var serviceInstance = serviceObject.object;\r
 722 \r
 723             setCurrentVolumeGroupModelInfoFromScope(vnf, vfModule);\r
 724 \r
 725             DataService.setInventoryItem(volumeGroup.object);\r
 726 \r
 727             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
 728             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 729             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 730 \r
 731             DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);\r
 732             DataService.setServiceInstanceName($scope.service.instance.name);\r
 733 \r
 734             DataService.setServiceName($scope.service.model.service.name);\r
 735 \r
 736             DataService.setServiceUuid($scope.service.model.service.uuid);\r
 737             DataService.setVnfInstanceId(vnf.nodeId);\r
 738             DataService.setVolumeGroupInstanceId(volumeGroup.nodeId);\r
 739 \r
 740             $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {\r
 741                 componentId: COMPONENT.VOLUME_GROUP,\r
 742                 dialogMethod: COMPONENT.DELETE\r
 743             });\r
 744         };\r
 745 \r
 746         $scope.deleteVnfVolumeGroup = function (serviceObject, vnf, volumeGroup) {\r
 747 \r
 748             console.log("Removing Volume Group " + volumeGroup.name);\r
 749             var serviceInstance = serviceObject.object;\r
 750 \r
 751             DataService.setInventoryItem(volumeGroup.object);\r
 752 \r
 753             var svcModel = $scope.service.convertedModel;\r
 754 \r
 755             var vnfModelInvariantUuid = vnf.object[FIELD.ID.MODEL_INVAR_ID];\r
 756             var vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];\r
 757             var vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 758 \r
 759             var volGroupModelInvariantUuid = volumeGroup.object[FIELD.ID.MODEL_INVAR_ID];\r
 760             var volGroupModelVersionId = volumeGroup.object[FIELD.ID.MODEL_VERSION_ID];\r
 761             var volGroupModelCustomizationUuid = volumeGroup.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 762 \r
 763             var vnfModel = null;\r
 764             var volGroupModel = null;\r
 765 \r
 766             // send an empty model by default since model is not required for deletes\r
 767             DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {});\r
 768 \r
 769             if (svcModel.isNewFlow) {\r
 770                 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];\r
 771                 if (UtilityService.hasContents(volGroupModelCustomizationUuid)) {\r
 772                     volGroupModel = vnfModel.volumeGroups[volGroupModelCustomizationUuid];\r
 773                 }\r
 774             }\r
 775             else {\r
 776 \r
 777                 vnfModel = svcModel.vnfs[vnfModelVersionId];\r
 778                 if (UtilityService.hasContents(volGroupModelVersionId)) {\r
 779                     volGroupModel = vnfModel.volumeGroups[volGroupModelVersionId];\r
 780                 }\r
 781             }\r
 782             if (!($scope.isObjectEmpty(volGroupModel))) {\r
 783                 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {\r
 784                     "modelInvariantId": volGroupModel.invariantUuid,\r
 785                     "modelVersion": volGroupModel.version,\r
 786                     "modelNameVersionId": volGroupModel.uuid,\r
 787                     "modelName": volGroupModel.name,\r
 788                     "modelCustomizationName": volGroupModel.modelCustomizationName,\r
 789                     "customizationUuid": volGroupModel.customizationUuid,\r
 790                     "inputs": ""\r
 791                 });\r
 792             }\r
 793 \r
 794             DataService.setVnfInstanceId(vnf.object[FIELD.ID.VNF_ID]);\r
 795 \r
 796             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
 797             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 798             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 799 \r
 800             DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);\r
 801             DataService.setServiceInstanceName($scope.service.instance.name);\r
 802 \r
 803             DataService.setServiceName($scope.service.model.service.name);\r
 804 \r
 805             DataService.setServiceUuid($scope.service.model.service.uuid);\r
 806             DataService.setVnfInstanceId(vnf.nodeId);\r
 807             DataService.setVolumeGroupInstanceId(volumeGroup.nodeId);\r
 808 \r
 809             $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {\r
 810                 componentId: COMPONENT.VOLUME_GROUP,\r
 811                 callbackFunction: deleteOrResumeCallback,\r
 812                 dialogMethod: COMPONENT.DELETE\r
 813             });\r
 814         };\r
 815 \r
 816         $scope.describeNetwork = function (serviceObject, networkObject) {\r
 817             var serviceInstance = serviceObject.object;\r
 818             var network = networkObject.object;\r
 819             //console.log ("networkObject="); console.log (JSON.stringify(networkObject, null, 4));\r
 820 \r
 821             DataService.setResCustomizationUuid(" ");\r
 822 \r
 823             setCurrentServiceModelInfoFromScope();\r
 824             setCurrentNetworkModelInfoFromScope(networkObject);\r
 825 \r
 826             DataService.setNetworkInstanceId(network[FIELD.ID.NETWORK_ID]);\r
 827             DataService.setInventoryItem(networkObject);\r
 828             DataService.setSubscriberName(serviceObject.subscriberName);\r
 829             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 830             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 831 \r
 832             $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {\r
 833                 componentId: COMPONENT.NETWORK\r
 834             });\r
 835         };\r
 836 \r
 837         // for service instance id - no need for this!\r
 838         $scope.describeService = function (serviceObject) {\r
 839             var serviceInstance = serviceObject.object;\r
 840             setCurrentServiceModelInfoFromScope();\r
 841 \r
 842             DataService.setInventoryItem(serviceInstance);\r
 843             //DataService.setModelInfo(serviceInstance['service-instance-id'], serviceInstance);\r
 844 \r
 845             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
 846             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 847             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 848 \r
 849             //Display popup with additional service information\r
 850             $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {\r
 851                 componentId: COMPONENT.SERVICE\r
 852             });\r
 853 \r
 854         };\r
 855 \r
 856         $scope.describeVfModule = function (serviceObject, vfModuleObject, vnf) {\r
 857             var serviceInstance = serviceObject.object;\r
 858             var vfModule = vfModuleObject.object;\r
 859 \r
 860             /*var vfModuleInvariantUuid = vfModule[FIELD.ID.MODEL_INVAR_ID];\r
 861             var vfModuleModelVersionId = vfModule[FIELD.ID.MODEL_VERSION_ID];*/\r
 862             var vfModuleCustomizationUuid = vfModule[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 863 \r
 864             setCurrentServiceModelInfoFromScope();\r
 865             setCurrentVfModuleModelInfoFromScope(vnf, vfModuleObject);\r
 866 \r
 867             DataService.setCustomizationUuid(" ");\r
 868             if (UtilityService.hasContents(vfModuleCustomizationUuid)) {\r
 869                 DataService.setCustomizationUuid(vfModuleCustomizationUuid);\r
 870             }\r
 871 \r
 872             //Display popup with additional VF-Module information\r
 873             DataService.setVfModuleInstanceId(vfModule[FIELD.ID.VF_MODULE_ID]);\r
 874             DataService.setInventoryItem(vfModule);\r
 875 \r
 876             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
 877             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 878             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 879 \r
 880             $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {\r
 881                 componentId: COMPONENT.VF_MODULE\r
 882             });\r
 883         };\r
 884 \r
 885         $scope.getStatusOfVnf = function (serviceObject, vnfObject) {\r
 886             var serviceInstance = serviceObject.object;\r
 887             var vnf = vnfObject.object;\r
 888 \r
 889             DataService.setVnfInstanceId(vnf[FIELD.ID.VNF_ID]);\r
 890             DataService.setInventoryItem(vnf);\r
 891 \r
 892             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
 893             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 894             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 895             DataService.setServiceInstanceName(serviceInstance[FIELD.ID.SERVICE_INSTANCE_NAME]);\r
 896 \r
 897             $scope.$broadcast(COMPONENT.COMPONENT_STATUS, {\r
 898                 componentId: COMPONENT.VNF,\r
 899                 callbackFunction: updateProvStatusVnfCallbackFunction\r
 900             });\r
 901         };\r
 902 \r
 903         $scope.describeVnf = function (serviceObject, vnfObject) {\r
 904             var serviceInstance = serviceObject.object;\r
 905             var vnf = vnfObject.object;\r
 906             DataService.setResCustomizationUuid(" ");\r
 907 \r
 908             //var vnfInvariantUuid = vnf[FIELD.ID.MODEL_INVAR_ID];\r
 909             //var vnfVersionId = vnf[FIELD.ID.MODEL_VERSION_ID];\r
 910             var vnfCustomizationUuid = vnf[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 911 \r
 912             if (UtilityService.hasContents(vnfCustomizationUuid)) {\r
 913                 DataService.setResCustomizationUuid(vnfCustomizationUuid);\r
 914             }\r
 915 \r
 916             setCurrentServiceModelInfoFromScope();\r
 917             setCurrentVNFModelInfo(vnfObject);\r
 918 \r
 919             //Display popup with additional VNF information\r
 920             DataService.setVnfInstanceId(vnf[FIELD.ID.VNF_ID]);\r
 921             DataService.setInventoryItem(vnf);\r
 922 \r
 923             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
 924             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 925             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 926 \r
 927             $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {\r
 928                 componentId: COMPONENT.VNF\r
 929             });\r
 930         };\r
 931 \r
 932         $scope.describeVolumeGroup = function (serviceObject, vnf, volumeGroupObject) {\r
 933 \r
 934             var serviceInstance = serviceObject.object;\r
 935             var volumeGroup = volumeGroupObject.object;\r
 936 \r
 937             var volGroupCustomizationUuid = volumeGroup[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 938 \r
 939             setCurrentServiceModelInfoFromScope();\r
 940             setCurrentVolumeGroupModelInfoByVfModuleFromScope(vnf, volumeGroupObject);\r
 941 \r
 942             DataService.setCustomizationUuid(" ");\r
 943             if (UtilityService.hasContents(volGroupCustomizationUuid)) {\r
 944                 DataService.setCustomizationUuid(volGroupCustomizationUuid);\r
 945             }\r
 946             DataService.setVolumeGroupInstanceId(volumeGroup[FIELD.ID.VOLUME_GROUP_ID]);\r
 947             DataService.setInventoryItem(volumeGroup);\r
 948 \r
 949             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
 950             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 951             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 952 \r
 953 \r
 954             $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {\r
 955                 componentId: COMPONENT.VOLUME_GROUP\r
 956             });\r
 957         };\r
 958 \r
 959         $scope.addNetworkInstance = function (netModel, existingVnfs) {\r
 960 \r
 961             // For networks we assume that we always follow the new flow\r
 962             console.log("Adding network to service instance" + this.service.instance.name);\r
 963             if (VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED && (UtilityService.hasContents(existingVnfs)) && (existingVnfs.length > 0)) {\r
 964                 var msg = VnfService.isVnfListStatusValid(existingVnfs);\r
 965                 if (msg != "") {\r
 966                     alert(msg);\r
 967                     return;\r
 968                 }\r
 969             }\r
 970 \r
 971             DataService.setSubscriberName($scope.service.instance.subscriberName);\r
 972             DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);\r
 973             DataService.setServiceType($scope.service.instance.serviceType);\r
 974             DataService.setServiceInstanceName($scope.service.instance.name);\r
 975             DataService.setServiceInstanceId($scope.service.instance.id);\r
 976             DataService.setServiceName($scope.service.model.service.name);\r
 977 \r
 978             DataService.setModelInfo(COMPONENT.NETWORK, {\r
 979                 "modelType": "network",\r
 980                 "modelInvariantId": netModel.invariantUuid,\r
 981                 "modelVersion": netModel.version,\r
 982                 "modelNameVersionId": netModel.uuid,\r
 983                 "modelName": netModel.name,\r
 984                 "modelCustomizationName": netModel.modelCustomizationName,\r
 985                 "customizationUuid": netModel.customizationUuid,\r
 986                 "inputs": "",\r
 987                 "displayInputs": netModel.displayInputs\r
 988             });\r
 989             setCurrentServiceModelInfoFromScope();\r
 990 \r
 991 \r
 992             $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {\r
 993                 componentId: COMPONENT.NETWORK,\r
 994                 callbackFunction: createVnfCallbackFunction\r
 995             });\r
 996         };\r
 997 \r
 998         $scope.addVnfInstance = function (vnf, existingVnfs) {\r
 999 \r
1000             if (VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED && (UtilityService.hasContents(existingVnfs)) && (existingVnfs.length > 0)) {\r
1001                 var msg = VnfService.isVnfListStatusValid(existingVnfs);\r
1002                 if (msg != "") {\r
1003                     alert(msg);\r
1004                     return;\r
1005                 }\r
1006             }\r
1007 \r
1008             var isVfc = false;\r
1009 \r
1010             _.map($scope.service.model.vnfs, function (value, key) {\r
1011                 if (value.uuid == vnf.uuid) {\r
1012                     if (!_.isEmpty(value.vfcInstanceGroups)) {\r
1013                         isVfc = true;\r
1014                         var queryData = {\r
1015                             serviceModelId: $scope.service.model.service.uuid,\r
1016                             serviceInstanceID: $scope.service.instance.id,\r
1017                             globalCustomerId: $scope.service.instance.globalCustomerId,\r
1018                             serviceType: $scope.service.instance.serviceType,\r
1019                             serviceInstanceName: $scope.service.instance.name,\r
1020                             modelCustomizationName: value.modelCustomizationName,\r
1021                             modelCustomizationId: value.customizationUuid,\r
1022                             subscriberName: $scope.service.instance.subscriberName\r
1023                         };\r
1024 \r
1025                         $scope.$broadcast(COMPONENT.IFRAME_DIALOG, queryData);\r
1026                         return;\r
1027                     }\r
1028                 }\r
1029             });\r
1030 \r
1031             DataService.setSubscriberName($scope.service.instance.subscriberName);\r
1032             DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);\r
1033             DataService.setServiceType($scope.service.instance.serviceType);\r
1034             DataService.setServiceInstanceName($scope.service.instance.name);\r
1035             DataService.setServiceInstanceId($scope.service.instance.id);\r
1036             DataService.setServiceName($scope.service.model.service.name);\r
1037 \r
1038             console.log("existingVnfs: ");\r
1039             console.log(JSON.stringify(existingVnfs, null, 4));\r
1040             console.log("existingVnfs: ");\r
1041             console.log(JSON.stringify(existingVnfs, null, 4));\r
1042             var vnf_type = "";\r
1043             var vnf_role = "";\r
1044             var vnf_function = "";\r
1045             var vnf_code = "";\r
1046 \r
1047             if (UtilityService.hasContents(vnf.nfType)) {\r
1048                 vnf_type = vnf.nfType;\r
1049             }\r
1050             if (UtilityService.hasContents(vnf.nfRole)) {\r
1051                 vnf_role = vnf.nfRole;\r
1052             }\r
1053             if (UtilityService.hasContents(vnf.nfFunction)) {\r
1054                 vnf_function = vnf.nfFunction;\r
1055             }\r
1056             if (UtilityService.hasContents(vnf.nfCode)) {\r
1057                 vnf_code = vnf.nfCode;\r
1058             }\r
1059             DataService.setModelInfo(COMPONENT.VNF, {\r
1060                 "modelType": vnf.isPnf ? "pnf" : "vnf",\r
1061                 "modelInvariantId": vnf.invariantUuid,\r
1062                 "modelVersion": vnf.version,\r
1063                 "modelNameVersionId": vnf.uuid,\r
1064                 "modelName": vnf.name,\r
1065                 "modelCustomizationName": vnf.modelCustomizationName,\r
1066                 "customizationUuid": vnf.customizationUuid,\r
1067                 "inputs": "",\r
1068                 "displayInputs": vnf.displayInputs,\r
1069                 "vnfType": vnf_type,\r
1070                 "vnfRole": vnf_role,\r
1071                 "vnfFunction": vnf_function,\r
1072                 "vnfCode": vnf_code,\r
1073                 "properties": vnf.properties\r
1074             });\r
1075 \r
1076             DataService.setModelInstanceName($scope.service.model.service.name);\r
1077             setCurrentServiceModelInfoFromScope();\r
1078 \r
1079             if (vnf.isConfig) {\r
1080                 DataService.setServiceProxies($scope.service.model.serviceProxies);\r
1081                 DataService.setSourceServiceProxies(vnf.sourceNodes);\r
1082                 DataService.setCollectorServiceProxies(vnf.collectorNodes);\r
1083                 DataService.setConfigurationByPolicy(vnf.isConfigurationByPolicy);\r
1084                 $location.path("/addNetworkNode");\r
1085             } else if (vnf.isPnf) {\r
1086                 $location.path("/pnfSearchAssociation");\r
1087             } else if (isVfc) {\r
1088                 //do nothing\r
1089             } else {\r
1090                 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {\r
1091                     componentId: COMPONENT.VNF,\r
1092                     callbackFunction: createVnfCallbackFunction\r
1093                 });\r
1094             }\r
1095         };\r
1096 \r
1097         $scope.addVfModuleInstance = function (vnfInstance, vfModuleModel) {\r
1098 \r
1099             if (VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED) {\r
1100                 var msg = VnfService.isVnfStatusValid(vnfInstance);\r
1101                 if (msg != "") {\r
1102                     alert(msg);\r
1103                     return;\r
1104                 }\r
1105 \r
1106             }\r
1107             var svcModel = $scope.service.convertedModel;\r
1108             DataService.setSubscriberName($scope.service.instance.subscriberName);\r
1109             DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);\r
1110             DataService.setServiceType($scope.service.instance.serviceType);\r
1111             DataService.setServiceInstanceName($scope.service.instance.name);\r
1112             DataService.setServiceInstanceId($scope.service.instance.id);\r
1113             DataService.setServiceName($scope.service.model.service.name);\r
1114 \r
1115             var vnfModelInvariantUuid = vnfInstance.object[FIELD.ID.MODEL_INVAR_ID];\r
1116             var vnfModelVersionId = vnfInstance.object[FIELD.ID.MODEL_VERSION_ID];\r
1117             var vnfModelCustomizationUuid = vnfInstance.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
1118             var vnfModel = null;\r
1119             if (svcModel.isNewFlow) {\r
1120                 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];\r
1121             }\r
1122             else {\r
1123                 vnfModel = svcModel.vnfs[vnfModelVersionId];\r
1124             }\r
1125 \r
1126             var availableVolumeGroupList = [];\r
1127             angular.forEach(vnfInstance[FIELD.ID.AVAILABLEVOLUMEGROUPS], function (volumeGroupInstance, key) {\r
1128                 availableVolumeGroupList.push({"instance": volumeGroupInstance});\r
1129             });\r
1130 \r
1131             DataService.setAvailableVolumeGroupList(availableVolumeGroupList);\r
1132             setCurrentServiceModelInfoFromScope();\r
1133 \r
1134             DataService.setVnfInstanceId(vnfInstance.object[FIELD.ID.VNF_ID]);\r
1135 \r
1136             DataService.setModelInfo(COMPONENT.VNF, {\r
1137                 "modelInvariantId": vnfModel.invariantUuid,\r
1138                 "modelVersion": vnfModel.version,\r
1139                 "modelNameVersionId": vnfModel.uuid,\r
1140                 "modelName": vnfModel.name,\r
1141                 "modelCustomizationName": vnfModel.modelCustomizationName,\r
1142                 "customizationUuid": vnfModel.customizationUuid,\r
1143                 "inputs": ""\r
1144             });\r
1145 \r
1146             DataService.setModelInfo(COMPONENT.VF_MODULE, {\r
1147                 "modelInvariantId": vfModuleModel.invariantUuid,\r
1148                 "modelVersion": vfModuleModel.version,\r
1149                 "modelNameVersionId": vfModuleModel.uuid,\r
1150                 "customizationUuid": vfModuleModel.customizationUuid,\r
1151                 "modelCustomizationName": vfModuleModel.modelCustomizationName,\r
1152                 "modelName": vfModuleModel.name,\r
1153                 "inputs": ""\r
1154             });\r
1155 \r
1156             $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {\r
1157                 componentId: COMPONENT.VF_MODULE,\r
1158                 callbackFunction: createVfModuleCallbackFunction\r
1159             });\r
1160 \r
1161         };\r
1162 \r
1163         $scope.addVolumeGroupInstance = function (vnfInstance, volumeGroupModel) {\r
1164             if (VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED) {\r
1165                 var msg = VnfService.isVnfStatusValid(vnfInstance);\r
1166                 if (msg != "") {\r
1167                     alert(msg);\r
1168                     return;\r
1169                 }\r
1170             }\r
1171             var svcModel = $scope.service.convertedModel;\r
1172             DataService.setSubscriberName($scope.service.instance.subscriberName);\r
1173             DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);\r
1174             DataService.setServiceType($scope.service.instance.serviceType);\r
1175             DataService.setServiceInstanceName($scope.service.instance.name);\r
1176             DataService.setServiceInstanceId($scope.service.instance.id);\r
1177             DataService.setServiceName($scope.service.model.service.name);\r
1178             setCurrentServiceModelInfoFromScope();\r
1179 \r
1180             DataService.setModelInfo(COMPONENT.SERVICE, {\r
1181                 "modelInvariantId": $scope.service.model.service.invariantUuid,\r
1182                 "modelVersion": $scope.service.model.service.version,\r
1183                 "modelNameVersionId": $scope.service.model.service.uuid,\r
1184                 "modelName": $scope.service.model.service.name,\r
1185                 "inputs": ""\r
1186             });\r
1187 \r
1188             DataService.setVnfInstanceId(vnfInstance.object[FIELD.ID.VNF_ID]);\r
1189 \r
1190             var vnfModelInvariantUuid = vnfInstance.object[FIELD.ID.MODEL_INVAR_ID];\r
1191             var vnfModelVersionId = vnfInstance.object[FIELD.ID.MODEL_VERSION_ID];\r
1192             var vnfCustomizationUuid = vnfInstance.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
1193             var vnfModel = null;\r
1194 \r
1195             if (svcModel.isNewFlow) {\r
1196                 vnfModel = svcModel.vnfs[vnfCustomizationUuid];\r
1197             }\r
1198             else {\r
1199                 vnfModel = svcModel.vnfs[vnfModelVersionId];\r
1200             }\r
1201 \r
1202             DataService.setModelInfo(COMPONENT.VNF, {\r
1203                 "modelInvariantId": vnfModel.invariantUuid,\r
1204                 "modelVersion": vnfModel.version,\r
1205                 "modelNameVersionId": vnfModel.uuid,\r
1206                 "modelName": vnfModel.name,\r
1207                 "modelCustomizationName": vnfModel.modelCustomizationName,\r
1208                 "customizationUuid": vnfModel.customizationUuid,\r
1209                 "inputs": ""\r
1210             });\r
1211 \r
1212             DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {\r
1213                 "modelInvariantId": volumeGroupModel.invariantUuid,\r
1214                 "modelVersion": volumeGroupModel.version,\r
1215                 "modelNameVersionId": volumeGroupModel.uuid,\r
1216                 "modelName": volumeGroupModel.name,\r
1217                 "modelCustomizationName": volumeGroupModel.modelCustomizationName,\r
1218                 "customizationUuid": volumeGroupModel.customizationUuid,\r
1219                 "inputs": ""\r
1220             });\r
1221 \r
1222             $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {\r
1223                 componentId: COMPONENT.VOLUME_GROUP,\r
1224                 callbackFunction: createVolumeGroupCallbackFunction\r
1225             });\r
1226         };\r
1227 \r
1228         $scope.resume = function (serviceObject, vfModule, vnfModel) {\r
1229             populate_popup_vfModule(serviceObject, vfModule, vnfModel);\r
1230             setCurrentVNFModelInfo(vnfModel);\r
1231 \r
1232             var availableVolumeGroupList = [];\r
1233             angular.forEach(vfModule.volumeGroups, function (volumeGroupInstance, key) {\r
1234                 availableVolumeGroupList.push({"instance": volumeGroupInstance});\r
1235             });\r
1236 \r
1237             DataService.setAvailableVolumeGroupList(availableVolumeGroupList);\r
1238 \r
1239             DataService.setVfModuleInstanceName(vfModule.object[FIELD.ID.VF_MODULE_NAME]);\r
1240             setCurrentServiceModelInfoFromScope();\r
1241 \r
1242             if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_SOFT_DELETE_ALACARTE_VF_MODULE))  {\r
1243 \r
1244                 if (DataService.getLoggedInUserId())  {\r
1245                     openVfModuleWithHomingDataModal(COMPONENT.RESUME, vfModule);\r
1246                 }\r
1247                 else {\r
1248                     AaiService.getLoggedInUserID(function (response) {\r
1249                         var userID = response.data;\r
1250                         DataService.setLoggedInUserId(userID);\r
1251                         openVfModuleWithHomingDataModal(COMPONENT.RESUME, vfModule);\r
1252                     });\r
1253                 }\r
1254             }\r
1255             else {\r
1256                 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {\r
1257                     componentId: COMPONENT.VF_MODULE,\r
1258                     volumeGroups: vfModule.volumeGroups,\r
1259                     callbackFunction: deleteOrResumeCallback,\r
1260                     dialogMethod: COMPONENT.RESUME\r
1261                 });\r
1262             }\r
1263         };\r
1264 \r
1265         $scope.deleteConfiguration = function (serviceObject, configuration) {\r
1266             console.log("Deleting Configuration " + configuration.name);\r
1267 \r
1268             var serviceInstance = serviceObject.object;\r
1269             var svcModel = $scope.service.convertedModel;\r
1270             var configModel;\r
1271             DataService.setInventoryItem(configuration.object);\r
1272             // set model default and override later if found\r
1273             DataService.setModelInfo(COMPONENT.CONFIGURATION, {});\r
1274 \r
1275             if (configuration.object != null) {\r
1276 \r
1277                 //var netModelInvariantUuid = network.object[FIELD.ID.MODEL_INVAR_ID];\r
1278                 var configModelVersionId = configuration.object[FIELD.ID.MODEL_VERSION_ID]; // model uuid\r
1279                 var configModelCustomizationUuid = configuration.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
1280 \r
1281                 //configurations added to vnfs list, in order to be part of the "Add VNF" drop-down list\r
1282                 if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {\r
1283                     if ((svcModel.isNewFlow) && (UtilityService.hasContents(configModelCustomizationUuid))) {\r
1284                         configModel = svcModel.vnfs[configModelCustomizationUuid];\r
1285                     }\r
1286                     else {\r
1287 \r
1288                         if (UtilityService.hasContents(configModelVersionId)) {\r
1289                             configModel = svcModel.vnfs[configModelVersionId];\r
1290                         }\r
1291 \r
1292                     }\r
1293                 }\r
1294             }\r
1295             if (!($scope.isObjectEmpty(configModel))) {\r
1296                 DataService.setModelInfo(COMPONENT.CONFIGURATION, {\r
1297                     "modelInvariantId": configModel.invariantUuid,\r
1298                     "modelVersion": configModel.version,\r
1299                     "modelNameVersionId": configModel.uuid,\r
1300                     "modelCustomizationName": configModel.modelCustomizationName,\r
1301                     "customizationUuid": configModel.customizationUuid,\r
1302                     "modelName": configModel.name,\r
1303                     "inputs": ""\r
1304                 });\r
1305             }\r
1306 \r
1307             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
1308             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
1309             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
1310 \r
1311             DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);\r
1312             DataService.setServiceInstanceName($scope.service.instance.name);\r
1313             DataService.setServiceName($scope.service.model.service.name);\r
1314             DataService.setServiceUuid($scope.service.model.service.uuid);\r
1315             DataService.setConfigurationInstanceId(configuration.object[FIELD.ID.CONFIGURATION_ID]);\r
1316 \r
1317             $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {\r
1318                 componentId: COMPONENT.CONFIGURATION,\r
1319                 dialogMethod: COMPONENT.DELETE,\r
1320                 callbackFunction: deleteCallbackFunction\r
1321             });\r
1322         };\r
1323 \r
1324         var deleteCallbackFunction = function () {\r
1325             console.log('hi')\r
1326         };\r
1327 \r
1328         $scope.resetProgress = function () {\r
1329             $scope.percentProgress = 0;\r
1330             $scope.progressClass = FIELD.STYLE.PROGRESS_BAR_INFO;\r
1331         };\r
1332 \r
1333         $scope.setProgress = function (percentProgress) {\r
1334             percentProgress = parseInt(percentProgress);\r
1335             if (percentProgress >= 100) {\r
1336                 $scope.progressClass = FIELD.STYLE.PROGRESS_BAR_SUCCESS;\r
1337             }\r
1338 \r
1339             if (percentProgress < $scope.percentProgress) {\r
1340                 return;\r
1341             }\r
1342 \r
1343             $scope.percentProgress = percentProgress;\r
1344             $scope.progressWidth = {width: percentProgress + "%"};\r
1345             if (percentProgress >= 5) {\r
1346                 $scope.progressText = percentProgress + " %";\r
1347             } else {\r
1348                 // Hidden since color combination is barely visible when progress portion is narrow.\r
1349                 $scope.progressText = "";\r
1350             }\r
1351         };\r
1352         $scope.isObjectEmpty = function (o) {\r
1353             var len = 0;\r
1354             if (UtilityService.hasContents(o)) {\r
1355                 var keys = Object.keys(o);\r
1356                 len = keys.length;\r
1357                 if (len == 0) {\r
1358                     return true;\r
1359                 }\r
1360                 else {\r
1361                     return false;\r
1362                 }\r
1363             }\r
1364             else {\r
1365                 return true;\r
1366             }\r
1367         };\r
1368         $scope.isMacro = function () {\r
1369             return $scope.service && AsdcService.isMacro($scope.service.model);\r
1370         };\r
1371         $scope.reloadRoute = function () {\r
1372             $route.reload();\r
1373         };\r
1374 \r
1375 \r
1376         /*\r
1377 Private metthods\r
1378 */\r
1379 \r
1380         /*\r
1381         setPnf\r
1382         * set the controller pnf param using api call\r
1383         * return: void\r
1384          */\r
1385         function _setPnf(data) { // data is the $scope.service.instance object\r
1386             return PnfService.getPnfs(data)\r
1387                 .then(\r
1388                     function (response) {\r
1389                         return response.data;\r
1390                         // * can add here changes on the data that are needed to the view ( filter, ect..)\r
1391                     },\r
1392                     function (error) {\r
1393                         console.error(error);\r
1394                     }\r
1395                 );\r
1396         }\r
1397 \r
1398 \r
1399         function _setCr(data) { // data is the $scope.service.instance object\r
1400             return CrService.getCr(data)\r
1401                 .then(\r
1402                     function (response) {\r
1403                         return response.data.results;\r
1404                         // * can add here changes on the data that are needed to the view ( filter, ect..)\r
1405                     },\r
1406                     function (error) {\r
1407                         console.error(error);\r
1408                     }\r
1409                 );\r
1410         }\r
1411 \r
1412 \r
1413         /*\r
1414         Callbaks functions\r
1415 \r
1416          */\r
1417         var updateProvStatusVnfCallbackFunction = function (response) {\r
1418             $scope.callbackResults = "";\r
1419             var color = FIELD.ID.COLOR_NONE;\r
1420             $scope.callbackStyle = {\r
1421                 "background-color": color\r
1422             };\r
1423             $scope.reloadRoute();\r
1424             /*\r
1425              * This 1/2 delay was only added to visually highlight the status\r
1426              * change. Probably not needed in the real application code.\r
1427              */\r
1428             $timeout(function () {\r
1429                 $scope.callbackResults = UtilityService.getCurrentTime()\r
1430                     + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;\r
1431                 if (response.isSuccessful) {\r
1432                     color = FIELD.ID.COLOR_8F8;\r
1433 \r
1434                 } else {\r
1435                     color = FIELD.ID.COLOR_F88;\r
1436                 }\r
1437                 $scope.callbackStyle = {\r
1438                     "background-color": color\r
1439                 };\r
1440             }, 500);\r
1441 \r
1442         };\r
1443 \r
1444         var createVnfCallbackFunction = function (response) {\r
1445             $scope.callbackResults = "";\r
1446             var color = FIELD.ID.COLOR_NONE;\r
1447             $scope.callbackStyle = {\r
1448                 "background-color": color\r
1449             };\r
1450 \r
1451             /*\r
1452              * This 1/2 delay was only added to visually highlight the status\r
1453              * change. Probably not needed in the real application code.\r
1454              */\r
1455             $timeout(function () {\r
1456                 $scope.callbackResults = UtilityService.getCurrentTime()\r
1457                     + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;\r
1458                 if (response.isSuccessful) {\r
1459                     color = FIELD.ID.COLOR_8F8;\r
1460                     $scope.reloadRoute();\r
1461                 } else {\r
1462                     color = FIELD.ID.COLOR_F88;\r
1463                 }\r
1464                 $scope.callbackStyle = {\r
1465                     "background-color": color\r
1466                 };\r
1467             }, 500);\r
1468 \r
1469 \r
1470         };\r
1471 \r
1472         var deleteOrResumeCallback = function (response) {\r
1473             $scope.callbackResults = "";\r
1474             var color = FIELD.ID.COLOR_NONE;\r
1475             $scope.callbackStyle = {\r
1476                 "background-color": color\r
1477             };\r
1478 \r
1479             /*\r
1480              * This 1/2 delay was only added to visually highlight the status\r
1481              * change. Probably not needed in the real application code.\r
1482              */\r
1483             $timeout(function () {\r
1484                 $scope.callbackResults = UtilityService.getCurrentTime()\r
1485                     + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;\r
1486                 if (response.isSuccessful) {\r
1487                     color = FIELD.ID.COLOR_8F8;\r
1488                     $scope.reloadRoute();\r
1489                 } else {\r
1490                     color = FIELD.ID.COLOR_F88;\r
1491                 }\r
1492                 $scope.callbackStyle = {\r
1493                     "background-color": color\r
1494                 };\r
1495             }, 500);\r
1496 \r
1497         };\r
1498 \r
1499         var createVfModuleCallbackFunction = function (response) {\r
1500             $scope.callbackResults = "";\r
1501             var color = FIELD.ID.COLOR_NONE;\r
1502             $scope.callbackStyle = {\r
1503                 "background-color": color\r
1504             };\r
1505 \r
1506             /*\r
1507              * This 1/2 delay was only added to visually highlight the status\r
1508              * change. Probably not needed in the real application code.\r
1509              */\r
1510             $timeout(function () {\r
1511                 $scope.callbackResults = UtilityService.getCurrentTime()\r
1512                     + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;\r
1513                 if (response.isSuccessful) {\r
1514                     color = FIELD.ID.COLOR_8F8;\r
1515                     $scope.reloadRoute();\r
1516                 } else {\r
1517                     color = FIELD.ID.COLOR_F88;\r
1518                 }\r
1519                 $scope.callbackStyle = {\r
1520                     "background-color": color\r
1521                 };\r
1522             }, 500);\r
1523 \r
1524         };\r
1525 \r
1526         var deleteServiceInstanceCallbackFunction = function (response) {\r
1527             $scope.callbackResults = "";\r
1528             var color = FIELD.ID.COLOR_NONE;\r
1529             $scope.callbackStyle = {\r
1530                 "background-color": color\r
1531             };\r
1532 \r
1533             /*\r
1534              * This 1/2 delay was only added to visually highlight the status\r
1535              * change. Probably not needed in the real application code.\r
1536              */\r
1537             $timeout(function () {\r
1538                 $scope.callbackResults = UtilityService.getCurrentTime()\r
1539                     + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;\r
1540                 if (response.isSuccessful) {\r
1541                     color = FIELD.ID.COLOR_8F8;\r
1542                     $location.path(COMPONENT.SERVICEMODELS_MODELS_SERVICES_PATH);\r
1543                 } else {\r
1544                     color = FIELD.ID.COLOR_F88;\r
1545                 }\r
1546                 $scope.callbackStyle = {\r
1547                     "background-color": color\r
1548                 };\r
1549             }, 500);\r
1550 \r
1551         };\r
1552 \r
1553         var createVolumeGroupCallbackFunction = function (response) {\r
1554             $scope.callbackResults = "";\r
1555             var color = FIELD.ID.COLOR_NONE;\r
1556             $scope.callbackStyle = {\r
1557                 "background-color": color\r
1558             };\r
1559 \r
1560             /*\r
1561              * This 1/2 delay was only added to visually highlight the status\r
1562              * change. Probably not needed in the real application code.\r
1563              */\r
1564             $timeout(function () {\r
1565                 $scope.callbackResults = UtilityService.getCurrentTime()\r
1566                     + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;\r
1567                 if (response.isSuccessful) {\r
1568                     color = FIELD.ID.COLOR_8F8;\r
1569                     $scope.reloadRoute();\r
1570                 } else {\r
1571                     color = FIELD.ID.COLOR_F88;\r
1572                 }\r
1573                 $scope.callbackStyle = {\r
1574                     "background-color": color\r
1575                 };\r
1576             }, 500);\r
1577 \r
1578 \r
1579         };\r
1580 \r
1581     });\r
1582 })();\r