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

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