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