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

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