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