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