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