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

   1 /*-\r
   2  * ============LICENSE_START=======================================================\r
   3  * VID\r
   4  * ================================================================================\r
   5  * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.\r
   6  * Modifications Copyright (C) 2019 IBM.\r
   7  * ================================================================================\r
   8  * Licensed under the Apache License, Version 2.0 (the "License");\r
   9  * you may not use this file except in compliance with the License.\r
  10  * You may obtain a copy of the License at\r
  11  * \r
  12  *      http://www.apache.org/licenses/LICENSE-2.0\r
  13  * \r
  14  * Unless required by applicable law or agreed to in writing, software\r
  15  * distributed under the License is distributed on an "AS IS" BASIS,\r
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  17  * See the License for the specific language governing permissions and\r
  18  * limitations under the License.\r
  19  * ============LICENSE_END=========================================================\r
  20  */\r
  21 \r
  22 /**\r
  23  * The Instantiation (or View/Edit) Controller controls the instantiation/removal of\r
  24  * deployable objects (Services, VNFs, VF-Modules, Networks, and Volume-Groups)\r
  25  */\r
  26 (function () {\r
  27     "use strict";\r
  28 \r
  29     appDS2.requires.push('ui.tree');\r
  30 \r
  31     appDS2.controller("InstantiationController", function ($scope, $route, $location, $timeout, $uibModal, COMPONENT, VIDCONFIGURATION, FIELD, DataService, PropertyService, UtilityService, VnfService, $http, vidService, AaiService, PnfService, CrService, AsdcService, $q, featureFlags, _, CreationService, $window, DeleteResumeService) {\r
  32         $scope.popup = new Object();\r
  33         $scope.defaultBaseUrl = "";\r
  34         $scope.responseTimeoutMsec = 60000;\r
  35         $scope.properties = UtilityService.getProperties();\r
  36         $scope.resumeStatus = COMPONENT.RESUME_STATUS;\r
  37         //isPermitted - returned as string from url and converted into boolean\r
  38         $scope.isPermitted = $location.search().isPermitted === "true";\r
  39         $scope.STATUS_CONSTANTS = FIELD.STATUS;\r
  40         $scope.pnfs = [];// PNF data init;\r
  41         $scope.collectionResource = {};\r
  42         $scope.collections = [];\r
  43         $scope.networks = [];\r
  44         $scope.isCR = false;\r
  45         $scope.isVFC = false;\r
  46         $scope.init = function () {\r
  47             /*\r
  48              * These 2 statements should be included in non-test code.\r
  49              */\r
  50             // takes a default value, retrieves the prop value from the file system and sets it\r
  51             var msecs = PropertyService.retrieveMsoMaxPollingIntervalMsec();\r
  52             PropertyService.setMsoMaxPollingIntervalMsec(msecs);\r
  53 \r
  54             // takes a default value, retrieves the prop value from the file system and sets it\r
  55             var polls = PropertyService.retrieveMsoMaxPolls();\r
  56             PropertyService.setMsoMaxPolls(polls);\r
  57         };\r
  58 \r
  59 \r
  60         $scope.convertModel = function (asdcModel) {\r
  61             if (!asdcModel) return undefined;\r
  62             var convertedAsdcModel = UtilityService.convertModel(asdcModel);\r
  63             return convertedAsdcModel;\r
  64         };\r
  65 \r
  66         $scope.prepareScopeWithModel = function () {\r
  67             // skip if no model\r
  68             if (!vidService.getModel()) return;\r
  69 \r
  70             $scope.service = {\r
  71                 "model": vidService.getModel(),\r
  72                 "convertedModel": $scope.convertModel(vidService.getModel()),\r
  73                 "instance": vidService.getInstance()\r
  74             };\r
  75 \r
  76 \r
  77             $scope.isCR = !_.isEmpty($scope.service.model.collectionResources);\r
  78             if ($scope.isCR)\r
  79                 prepareCr();\r
  80             else\r
  81                 preparePnfs();\r
  82         };\r
  83 \r
  84         function preparePnfs() {\r
  85             var serviceInstance = {\r
  86                 globalCustomerId: $location.search().subscriberId,\r
  87                 serviceType: $location.search().serviceType,\r
  88                 serviceInstanceId: $location.search().serviceInstanceId\r
  89             };\r
  90 \r
  91             _setPnf(serviceInstance).then(function (data) {\r
  92                 $scope.pnfs = data;\r
  93             });\r
  94         }\r
  95 \r
  96 \r
  97         function prepareCr() {\r
  98             var serviceInstance = {\r
  99                 globalCustomerId: $location.search().subscriberId,\r
 100                 serviceType: $location.search().serviceType,\r
 101                 serviceInstanceId: $location.search().serviceInstanceId\r
 102             };\r
 103 \r
 104             _setCr(serviceInstance).then(function (data) {\r
 105                 $scope.collectionResource = data;\r
 106                 $scope.collections.push($scope.collectionResource.collection);\r
 107                 $scope.networks.push($scope.collectionResource.networks[0]);\r
 108             });\r
 109         }\r
 110 \r
 111         $scope.returnVfModules = function (vnfInstance) {\r
 112 \r
 113             var svcModel = $scope.service.convertedModel;\r
 114             //var vnfModelInvariantUuid = vnfInstance[FIELD.ID.MODEL_INVAR_ID];\r
 115             var vnfModelVersionId = vnfInstance[FIELD.ID.MODEL_VERSION_ID]; // model uuid\r
 116             var vnfModelCustomizationUuid = vnfInstance[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 117 \r
 118             var vnfModel = null;\r
 119 \r
 120             if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {\r
 121                 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {\r
 122                     vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];\r
 123                     if (vnfModel !== undefined) {\r
 124                         if (!($scope.isObjectEmpty(vnfModel.vfModules))) {\r
 125                             //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.vfModules, null, 4));\r
 126                             return (vnfModel.vfModules);\r
 127                         }\r
 128                     }\r
 129                 }\r
 130                 else {\r
 131                     // old flow\r
 132                     if (vnfModelVersionId != null) {\r
 133                         vnfModel = svcModel.vnfs[vnfModelVersionId];\r
 134                         if (vnfModel !== undefined) {\r
 135                             if (!($scope.isObjectEmpty(vnfModel.vfModules))) {\r
 136                                 //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.vfModules, null, 4));\r
 137                                 return (vnfModel.vfModules);\r
 138                             }\r
 139                         }\r
 140                     }\r
 141                 }\r
 142 \r
 143             }\r
 144             return null;\r
 145         };\r
 146         $scope.hasVfModules = function (vnfInstance) {\r
 147             if ($scope.returnVfModules(vnfInstance) != null) {\r
 148                 return true;\r
 149             }\r
 150             return false;\r
 151         };\r
 152         $scope.returnVolumeGroups = function (vnfInstance) {\r
 153 \r
 154             var svcModel = $scope.service.convertedModel;\r
 155 \r
 156             //var vnfModelInvariantUuid = vnfInstance[FIELD.ID.MODEL_INVAR_ID];\r
 157             var vnfModelVersionId = vnfInstance[FIELD.ID.MODEL_VERSION_ID];\r
 158             var vnfModelCustomizationUuid = vnfInstance[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
 159 \r
 160             var vnfModel = null;\r
 161 \r
 162             if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {\r
 163                 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {\r
 164                     vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];\r
 165                     if (vnfModel !== undefined) {\r
 166 \r
 167                         if (!($scope.isObjectEmpty(vnfModel.volumeGroups))) {\r
 168                             //console.log ("vnfModel.volumeGroups: "); console.log (JSON.stringify(vnfModel.volumeGroups, null, 4));\r
 169                             return (vnfModel.volumeGroups);\r
 170                         }\r
 171                     }\r
 172                 }\r
 173                 else {\r
 174                     // old flow\r
 175                     if (vnfModelVersionId != null) {\r
 176                         vnfModel = svcModel.vnfs[vnfModelVersionId];\r
 177                         if (!($scope.isObjectEmpty(vnfModel.volumeGroups))) {\r
 178                             //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.volumeGroups, null, 4));\r
 179                             return (vnfModel.volumeGroups);\r
 180                         }\r
 181                     }\r
 182                 }\r
 183 \r
 184             }\r
 185             return null;\r
 186         };\r
 187         $scope.hasVolumeGroups = function (vnfInstance) {\r
 188             if ($scope.returnVolumeGroups(vnfInstance) != null) {\r
 189                 return true;\r
 190             }\r
 191             return false;\r
 192         };\r
 193         $scope.deleteNetwork = function (serviceObject, network) {\r
 194 \r
 195             console.log("Removing Network " + network.name);\r
 196 \r
 197             //Send delete network request to MSO\r
 198 \r
 199             //var networks = this.service.instance.networks;\r
 200 \r
 201             //networks.splice(networks.indexOf(network), 1);\r
 202 \r
 203             //Retrieve updated data from A&AI\r
 204             var serviceInstance = serviceObject.object;\r
 205 \r
 206             setCurrentNetworkModelInfoFromScope(network);\r
 207 \r
 208             DataService.setInventoryItem(network.object);\r
 209 \r
 210             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
 211             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 212             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 213 \r
 214             DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);\r
 215             DataService.setServiceInstanceName($scope.service.instance.name);\r
 216             DataService.setServiceName($scope.service.model.service.name);\r
 217             DataService.setServiceUuid($scope.service.model.service.uuid);\r
 218             DataService.setNetworkInstanceId(network.object[FIELD.ID.NETWORK_ID]);\r
 219 \r
 220             $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {\r
 221                 componentId: COMPONENT.NETWORK,\r
 222                 callbackFunction: deleteOrResumeCallback,\r
 223                 dialogMethod: COMPONENT.DELETE\r
 224             });\r
 225         };\r
 226 \r
 227         $scope.allowTransferToNewScreenAndShowButton = function (){\r
 228           if(featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_FLASH_MORE_ACTIONS_BUTTON_IN_OLD_VIEW_EDIT)) {\r
 229               return $scope.isPermitted;\r
 230           }\r
 231           return false;\r
 232         };\r
 233 \r
 234         $scope.navigateToNewEditViewScreen = function(){\r
 235                 window.location.href = 'serviceModels.htm#/servicePlanning/EDIT?' +\r
 236                     'serviceModelId=' +     _.get($scope, 'service.model.service.uuid') +\r
 237                     '&subscriberId=' +      $location.search().subscriberId  +\r
 238                     '&serviceType=' +       $location.search().serviceType      +\r
 239                     '&serviceInstanceId=' + $location.search().serviceInstanceId;\r
 240         };\r
 241 \r
 242         $scope.deleteService = function (serviceObject, serviceOrchestrationStatus) {\r
 243 \r
 244             var serviceInstance = serviceObject.object;\r
 245 \r
 246             console.log("Removing Service " + $scope.service.instance.name);\r
 247 \r
 248             if ($scope.isMacro()) {\r
 249                 DataService.setALaCarte(false);\r
 250             }\r
 251             else {\r
 252                 DataService.setALaCarte(true);\r
 253             }\r
 254             DataService.setMacro($scope.isMacro());\r
 255             DataService.setInventoryItem(serviceInstance);\r
 256             setCurrentServiceModelInfoFromScope();\r
 257 \r
 258 \r
 259             DataService.setSubscriberName(serviceObject[FIELD.ID.SUBSCRIBER_NAME]);\r
 260             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 261             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 262 \r
 263             DataService.setGlobalCustomerId(serviceObject[COMPONENT.GLOBAL_CUSTOMER_ID]);\r
 264             DataService.setServiceInstanceName($scope.service.instance.name);\r
 265 \r
 266             DataService.setServiceName($scope.service.model.service.name);\r
 267 \r
 268             DataService.setServiceUuid($scope.service.model.service.uuid);\r
 269 \r
 270             $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {\r
 271                 componentId: COMPONENT.SERVICE,\r
 272                 callbackFunction: deleteServiceInstanceCallbackFunction,\r
 273                 dialogMethod: COMPONENT.DELETE,\r
 274                 serviceStatus: serviceOrchestrationStatus\r
 275             });\r
 276 \r
 277         };\r
 278 \r
 279         function populate_popup_vfModule(serviceObject, vfModule, vnf) {\r
 280             var serviceInstance = serviceObject.object;\r
 281 \r
 282             DataService.setInventoryItem(vfModule.object);\r
 283 \r
 284             setCurrentVfModuleModelInfoFromScope(vnf, vfModule);\r
 285             var vfModuleInstanceID = vfModule.object[FIELD.ID.VF_MODULE_ID];\r
 286             if (vfModuleInstanceID == null) {\r
 287                 vfModuleInstanceID = "";\r
 288             }\r
 289 \r
 290             DataService.setVnfInstanceId(vnf.object[FIELD.ID.VNF_ID]);\r
 291             DataService.setVfModuleInstanceId(vfModuleInstanceID);\r
 292 \r
 293             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
 294             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
 295             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
 296 \r
 297             DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);\r
 298             DataService.setServiceInstanceName($scope.service.instance.name);\r
 299 \r
 300             DataService.setServiceName($scope.service.model.service.name);\r
 301 \r
 302             DataService.setServiceUuid($scope.service.model.service.uuid);\r
 303         }\r
 304 \r
 305         var modalInstance;\r
 306 \r
 307         var openMsoModal = function (msoType, requestParams, callbackFunction, configuration) {\r
 308              modalInstance = $uibModal.open({\r
 309                 templateUrl: 'app/vid/scripts/modals/mso-commit/mso-commit.html',\r
 310                 controller: "msoCommitModalController",\r
 311                 backdrop: false,\r
 312                 resolve: {\r
 313                     msoType: function () {\r
 314                         return msoType;\r
 315                     },\r
 316                     requestParams: function () {\r
 317                         requestParams.callbackFunction = callbackFunction;\r
 318                         return requestParams;\r
 319                     },\r
 320                     configuration: function () {\r
 321                         return configuration;\r
 322                     }\r
 323                 }\r
 324             });\r
 325         };\r
 326 \r
 327         var openVfModuleWithHomingDataModal = function(action, vfModule)  {\r
 328             modalInstance = $uibModal.open({\r
 329                 controller: 'vfModuleActionModalController',\r
 330                 templateUrl: 'app/vid/scripts/modals/vf-module-homing-data-action/vf-module-homing-data-action.html',\r
 331                 backdrop: false,\r
 332                 resolve: {\r
 333                     action: function () {\r
 334                         return action;\r
 335                     },\r
 336                     vfModule: function() {\r
 337                         return vfModule;\r
 338                     }\r
 339                 }\r
 340             });\r
 341 \r
 342             modalInstance.result.then(function (data) {\r
 343                 if (data.msoType && data.requestParams) {\r
 344                     openMsoModal(data.msoType, data.requestParams, deleteOrResumeCallback, null);\r
 345                 }\r
 346             });\r
 347         };\r
 348 \r
 349         function getLcpCloudRegionTenantList() {\r
 350             AaiService.getLcpCloudRegionTenantList(DataService\r
 351                 .getGlobalCustomerId(), DataService.getServiceType(), function(\r
 352                 response) {\r
 353                 $scope.lcpAndTenant = response;\r
 354                 $scope.isFeatureFlagCloudOwner = featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST);\r
 355                 $scope.lcpRegionList = _.uniqBy(response, 'cloudRegionId');\r
 356             });\r
 357         }\r
 358 \r
 359         $scope.deleteVfModule = function (serviceObject, vfModule, vnf) {\r
 360             $scope.isSoftDeleteEnabled = true;\r
 361 \r
 362             populate_popup_vfModule(serviceObject, vfModule, vnf);\r
 363 \r
 364             if (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 && !_.isEmpty(value.vfcInstanceGroups)) {\r
1020                         isVfc = true;\r
1021                         var queryData = {\r
1022                             serviceModelId: $scope.service.model.service.uuid,\r
1023                             serviceInstanceID: $scope.service.instance.id,\r
1024                             globalCustomerId: $scope.service.instance.globalCustomerId,\r
1025                             serviceType: $scope.service.instance.serviceType,\r
1026                             serviceInstanceName: $scope.service.instance.name,\r
1027                             modelCustomizationName: value.modelCustomizationName,\r
1028                             modelCustomizationId: value.customizationUuid,\r
1029                             subscriberName: $scope.service.instance.subscriberName\r
1030                         };\r
1031 \r
1032                         $scope.$broadcast(COMPONENT.IFRAME_DIALOG, queryData);\r
1033                         return;\r
1034                     }\r
1035             });\r
1036 \r
1037             DataService.setSubscriberName($scope.service.instance.subscriberName);\r
1038             DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);\r
1039             DataService.setServiceType($scope.service.instance.serviceType);\r
1040             DataService.setServiceInstanceName($scope.service.instance.name);\r
1041             DataService.setServiceInstanceId($scope.service.instance.id);\r
1042             DataService.setServiceName($scope.service.model.service.name);\r
1043 \r
1044             console.log("existingVnfs: ");\r
1045             console.log(JSON.stringify(existingVnfs, null, 4));\r
1046             console.log("existingVnfs: ");\r
1047             console.log(JSON.stringify(existingVnfs, null, 4));\r
1048             var vnf_type = "";\r
1049             var vnf_role = "";\r
1050             var vnf_function = "";\r
1051             var vnf_code = "";\r
1052 \r
1053             if (UtilityService.hasContents(vnf.nfType)) {\r
1054                 vnf_type = vnf.nfType;\r
1055             }\r
1056             if (UtilityService.hasContents(vnf.nfRole)) {\r
1057                 vnf_role = vnf.nfRole;\r
1058             }\r
1059             if (UtilityService.hasContents(vnf.nfFunction)) {\r
1060                 vnf_function = vnf.nfFunction;\r
1061             }\r
1062             if (UtilityService.hasContents(vnf.nfCode)) {\r
1063                 vnf_code = vnf.nfCode;\r
1064             }\r
1065             DataService.setModelInfo(COMPONENT.VNF, {\r
1066                 "modelType": vnf.isPnf ? "pnf" : "vnf",\r
1067                 "modelInvariantId": vnf.invariantUuid,\r
1068                 "modelVersion": vnf.version,\r
1069                 "modelNameVersionId": vnf.uuid,\r
1070                 "modelName": vnf.name,\r
1071                 "modelCustomizationName": vnf.modelCustomizationName,\r
1072                 "customizationUuid": vnf.customizationUuid,\r
1073                 "inputs": "",\r
1074                 "displayInputs": vnf.displayInputs,\r
1075                 "vnfType": vnf_type,\r
1076                 "vnfRole": vnf_role,\r
1077                 "vnfFunction": vnf_function,\r
1078                 "vnfCode": vnf_code,\r
1079                 "properties": vnf.properties\r
1080             });\r
1081 \r
1082             DataService.setModelInstanceName($scope.service.model.service.name);\r
1083             setCurrentServiceModelInfoFromScope();\r
1084 \r
1085             if (vnf.isConfig) {\r
1086                 DataService.setServiceProxies($scope.service.model.serviceProxies);\r
1087                 DataService.setSourceServiceProxies(vnf.sourceNodes);\r
1088                 DataService.setCollectorServiceProxies(vnf.collectorNodes);\r
1089                 DataService.setConfigurationByPolicy(vnf.isConfigurationByPolicy);\r
1090                 $location.path("/addNetworkNode");\r
1091             } else if (vnf.isPnf) {\r
1092                 $location.path("/pnfSearchAssociation");\r
1093             } else if (isVfc) {\r
1094                 //do nothing\r
1095             } else {\r
1096                 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {\r
1097                     componentId: COMPONENT.VNF,\r
1098                     callbackFunction: createVnfCallbackFunction\r
1099                 });\r
1100             }\r
1101         };\r
1102 \r
1103         $scope.addVfModuleInstance = function (vnfInstance, vfModuleModel) {\r
1104 \r
1105             if (VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED) {\r
1106                 var msg = VnfService.isVnfStatusValid(vnfInstance);\r
1107                 if (msg != "") {\r
1108                     alert(msg);\r
1109                     return;\r
1110                 }\r
1111 \r
1112             }\r
1113             var svcModel = $scope.service.convertedModel;\r
1114             DataService.setSubscriberName($scope.service.instance.subscriberName);\r
1115             DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);\r
1116             DataService.setServiceType($scope.service.instance.serviceType);\r
1117             DataService.setServiceInstanceName($scope.service.instance.name);\r
1118             DataService.setServiceInstanceId($scope.service.instance.id);\r
1119             DataService.setServiceName($scope.service.model.service.name);\r
1120 \r
1121             var vnfModelInvariantUuid = vnfInstance.object[FIELD.ID.MODEL_INVAR_ID];\r
1122             var vnfModelVersionId = vnfInstance.object[FIELD.ID.MODEL_VERSION_ID];\r
1123             var vnfModelCustomizationUuid = vnfInstance.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
1124             var vnfModel = null;\r
1125             if (svcModel.isNewFlow) {\r
1126                 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];\r
1127             }\r
1128             else {\r
1129                 vnfModel = svcModel.vnfs[vnfModelVersionId];\r
1130             }\r
1131 \r
1132             var availableVolumeGroupList = [];\r
1133             angular.forEach(vnfInstance[FIELD.ID.AVAILABLEVOLUMEGROUPS], function (volumeGroupInstance, key) {\r
1134                 availableVolumeGroupList.push({"instance": volumeGroupInstance});\r
1135             });\r
1136 \r
1137             DataService.setAvailableVolumeGroupList(availableVolumeGroupList);\r
1138             setCurrentServiceModelInfoFromScope();\r
1139 \r
1140             DataService.setVnfInstanceId(vnfInstance.object[FIELD.ID.VNF_ID]);\r
1141 \r
1142             DataService.setModelInfo(COMPONENT.VNF, {\r
1143                 "modelInvariantId": vnfModel.invariantUuid,\r
1144                 "modelVersion": vnfModel.version,\r
1145                 "modelNameVersionId": vnfModel.uuid,\r
1146                 "modelName": vnfModel.name,\r
1147                 "modelCustomizationName": vnfModel.modelCustomizationName,\r
1148                 "customizationUuid": vnfModel.customizationUuid,\r
1149                 "inputs": ""\r
1150             });\r
1151 \r
1152             DataService.setModelInfo(COMPONENT.VF_MODULE, {\r
1153                 "modelInvariantId": vfModuleModel.invariantUuid,\r
1154                 "modelVersion": vfModuleModel.version,\r
1155                 "modelNameVersionId": vfModuleModel.uuid,\r
1156                 "customizationUuid": vfModuleModel.customizationUuid,\r
1157                 "modelCustomizationName": vfModuleModel.modelCustomizationName,\r
1158                 "modelName": vfModuleModel.name,\r
1159                 "inputs": ""\r
1160             });\r
1161 \r
1162             $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {\r
1163                 componentId: COMPONENT.VF_MODULE,\r
1164                 callbackFunction: createVfModuleCallbackFunction\r
1165             });\r
1166 \r
1167         };\r
1168 \r
1169         $scope.addVolumeGroupInstance = function (vnfInstance, volumeGroupModel) {\r
1170             if (VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED) {\r
1171                 var msg = VnfService.isVnfStatusValid(vnfInstance);\r
1172                 if (msg != "") {\r
1173                     alert(msg);\r
1174                     return;\r
1175                 }\r
1176             }\r
1177             var svcModel = $scope.service.convertedModel;\r
1178             DataService.setSubscriberName($scope.service.instance.subscriberName);\r
1179             DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);\r
1180             DataService.setServiceType($scope.service.instance.serviceType);\r
1181             DataService.setServiceInstanceName($scope.service.instance.name);\r
1182             DataService.setServiceInstanceId($scope.service.instance.id);\r
1183             DataService.setServiceName($scope.service.model.service.name);\r
1184             setCurrentServiceModelInfoFromScope();\r
1185 \r
1186             DataService.setModelInfo(COMPONENT.SERVICE, {\r
1187                 "modelInvariantId": $scope.service.model.service.invariantUuid,\r
1188                 "modelVersion": $scope.service.model.service.version,\r
1189                 "modelNameVersionId": $scope.service.model.service.uuid,\r
1190                 "modelName": $scope.service.model.service.name,\r
1191                 "inputs": ""\r
1192             });\r
1193 \r
1194             DataService.setVnfInstanceId(vnfInstance.object[FIELD.ID.VNF_ID]);\r
1195 \r
1196             var vnfModelInvariantUuid = vnfInstance.object[FIELD.ID.MODEL_INVAR_ID];\r
1197             var vnfModelVersionId = vnfInstance.object[FIELD.ID.MODEL_VERSION_ID];\r
1198             var vnfCustomizationUuid = vnfInstance.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
1199             var vnfModel = null;\r
1200 \r
1201             if (svcModel.isNewFlow) {\r
1202                 vnfModel = svcModel.vnfs[vnfCustomizationUuid];\r
1203             }\r
1204             else {\r
1205                 vnfModel = svcModel.vnfs[vnfModelVersionId];\r
1206             }\r
1207 \r
1208             DataService.setModelInfo(COMPONENT.VNF, {\r
1209                 "modelInvariantId": vnfModel.invariantUuid,\r
1210                 "modelVersion": vnfModel.version,\r
1211                 "modelNameVersionId": vnfModel.uuid,\r
1212                 "modelName": vnfModel.name,\r
1213                 "modelCustomizationName": vnfModel.modelCustomizationName,\r
1214                 "customizationUuid": vnfModel.customizationUuid,\r
1215                 "inputs": ""\r
1216             });\r
1217 \r
1218             DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {\r
1219                 "modelInvariantId": volumeGroupModel.invariantUuid,\r
1220                 "modelVersion": volumeGroupModel.version,\r
1221                 "modelNameVersionId": volumeGroupModel.uuid,\r
1222                 "modelName": volumeGroupModel.name,\r
1223                 "modelCustomizationName": volumeGroupModel.modelCustomizationName,\r
1224                 "customizationUuid": volumeGroupModel.customizationUuid,\r
1225                 "inputs": ""\r
1226             });\r
1227 \r
1228             $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {\r
1229                 componentId: COMPONENT.VOLUME_GROUP,\r
1230                 callbackFunction: createVolumeGroupCallbackFunction\r
1231             });\r
1232         };\r
1233 \r
1234         $scope.resume = function (serviceObject, vfModule, vnfModel) {\r
1235             populate_popup_vfModule(serviceObject, vfModule, vnfModel);\r
1236             setCurrentVNFModelInfo(vnfModel);\r
1237 \r
1238             var availableVolumeGroupList = [];\r
1239             angular.forEach(vfModule.volumeGroups, function (volumeGroupInstance, key) {\r
1240                 availableVolumeGroupList.push({"instance": volumeGroupInstance});\r
1241             });\r
1242 \r
1243             DataService.setAvailableVolumeGroupList(availableVolumeGroupList);\r
1244 \r
1245             DataService.setVfModuleInstanceName(vfModule.object[FIELD.ID.VF_MODULE_NAME]);\r
1246             setCurrentServiceModelInfoFromScope();\r
1247 \r
1248             if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_SOFT_DELETE_ALACARTE_VF_MODULE))  {\r
1249 \r
1250                 if (DataService.getLoggedInUserId())  {\r
1251                     openVfModuleWithHomingDataModal(COMPONENT.RESUME, vfModule);\r
1252                 }\r
1253                 else {\r
1254                     AaiService.getLoggedInUserID(function (response) {\r
1255                         var userID = response.data;\r
1256                         DataService.setLoggedInUserId(userID);\r
1257                         openVfModuleWithHomingDataModal(COMPONENT.RESUME, vfModule);\r
1258                     });\r
1259                 }\r
1260             }\r
1261             else {\r
1262                 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {\r
1263                     componentId: COMPONENT.VF_MODULE,\r
1264                     volumeGroups: vfModule.volumeGroups,\r
1265                     callbackFunction: deleteOrResumeCallback,\r
1266                     dialogMethod: COMPONENT.RESUME\r
1267                 });\r
1268             }\r
1269         };\r
1270 \r
1271         $scope.deleteConfiguration = function (serviceObject, configuration) {\r
1272             console.log("Deleting Configuration " + configuration.name);\r
1273 \r
1274             var serviceInstance = serviceObject.object;\r
1275             var svcModel = $scope.service.convertedModel;\r
1276             var configModel;\r
1277             DataService.setInventoryItem(configuration.object);\r
1278             // set model default and override later if found\r
1279             DataService.setModelInfo(COMPONENT.CONFIGURATION, {});\r
1280 \r
1281             if (configuration.object != null) {\r
1282 \r
1283                 //var netModelInvariantUuid = network.object[FIELD.ID.MODEL_INVAR_ID];\r
1284                 var configModelVersionId = configuration.object[FIELD.ID.MODEL_VERSION_ID]; // model uuid\r
1285                 var configModelCustomizationUuid = configuration.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];\r
1286 \r
1287                 //configurations added to vnfs list, in order to be part of the "Add VNF" drop-down list\r
1288                 if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {\r
1289                     if ((svcModel.isNewFlow) && (UtilityService.hasContents(configModelCustomizationUuid))) {\r
1290                         configModel = svcModel.vnfs[configModelCustomizationUuid];\r
1291                     }\r
1292                     else {\r
1293 \r
1294                         if (UtilityService.hasContents(configModelVersionId)) {\r
1295                             configModel = svcModel.vnfs[configModelVersionId];\r
1296                         }\r
1297 \r
1298                     }\r
1299                 }\r
1300             }\r
1301             if (!($scope.isObjectEmpty(configModel))) {\r
1302                 DataService.setModelInfo(COMPONENT.CONFIGURATION, {\r
1303                     "modelInvariantId": configModel.invariantUuid,\r
1304                     "modelVersion": configModel.version,\r
1305                     "modelNameVersionId": configModel.uuid,\r
1306                     "modelCustomizationName": configModel.modelCustomizationName,\r
1307                     "customizationUuid": configModel.customizationUuid,\r
1308                     "modelName": configModel.name,\r
1309                     "inputs": ""\r
1310                 });\r
1311             }\r
1312 \r
1313             DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);\r
1314             DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);\r
1315             DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);\r
1316 \r
1317             DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);\r
1318             DataService.setServiceInstanceName($scope.service.instance.name);\r
1319             DataService.setServiceName($scope.service.model.service.name);\r
1320             DataService.setServiceUuid($scope.service.model.service.uuid);\r
1321             DataService.setConfigurationInstanceId(configuration.object[FIELD.ID.CONFIGURATION_ID]);\r
1322 \r
1323             $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {\r
1324                 componentId: COMPONENT.CONFIGURATION,\r
1325                 dialogMethod: COMPONENT.DELETE,\r
1326                 callbackFunction: deleteCallbackFunction\r
1327             });\r
1328         };\r
1329 \r
1330         var deleteCallbackFunction = function () {\r
1331             console.log('hi')\r
1332         };\r
1333 \r
1334         $scope.resetProgress = function () {\r
1335             $scope.percentProgress = 0;\r
1336             $scope.progressClass = FIELD.STYLE.PROGRESS_BAR_INFO;\r
1337         };\r
1338 \r
1339         $scope.setProgress = function (percentProgress) {\r
1340             percentProgress = parseInt(percentProgress);\r
1341             if (percentProgress >= 100) {\r
1342                 $scope.progressClass = FIELD.STYLE.PROGRESS_BAR_SUCCESS;\r
1343             }\r
1344 \r
1345             if (percentProgress < $scope.percentProgress) {\r
1346                 return;\r
1347             }\r
1348 \r
1349             $scope.percentProgress = percentProgress;\r
1350             $scope.progressWidth = {width: percentProgress + "%"};\r
1351             if (percentProgress >= 5) {\r
1352                 $scope.progressText = percentProgress + " %";\r
1353             } else {\r
1354                 // Hidden since color combination is barely visible when progress portion is narrow.\r
1355                 $scope.progressText = "";\r
1356             }\r
1357         };\r
1358         $scope.isObjectEmpty = function (o) {\r
1359             var len = 0;\r
1360             if (UtilityService.hasContents(o)) {\r
1361                 var keys = Object.keys(o);\r
1362                 len = keys.length;\r
1363                 if (len == 0) {\r
1364                     return true;\r
1365                 }\r
1366                 else {\r
1367                     return false;\r
1368                 }\r
1369             }\r
1370             else {\r
1371                 return true;\r
1372             }\r
1373         };\r
1374         $scope.isMacro = function () {\r
1375             return $scope.service && AsdcService.isMacro($scope.service.model);\r
1376         };\r
1377         $scope.reloadRoute = function () {\r
1378             $route.reload();\r
1379         };\r
1380 \r
1381 \r
1382         /*\r
1383 Private metthods\r
1384 */\r
1385 \r
1386         /*\r
1387         setPnf\r
1388         * set the controller pnf param using api call\r
1389         * return: void\r
1390          */\r
1391         function _setPnf(data) { // data is the $scope.service.instance object\r
1392             return PnfService.getPnfs(data)\r
1393                 .then(\r
1394                     function (response) {\r
1395                         return response.data;\r
1396                         // * can add here changes on the data that are needed to the view ( filter, ect..)\r
1397                     },\r
1398                     function (error) {\r
1399                         console.error(error);\r
1400                     }\r
1401                 );\r
1402         }\r
1403 \r
1404 \r
1405         function _setCr(data) { // data is the $scope.service.instance object\r
1406             return CrService.getCr(data)\r
1407                 .then(\r
1408                     function (response) {\r
1409                         return response.data.results;\r
1410                         // * can add here changes on the data that are needed to the view ( filter, ect..)\r
1411                     },\r
1412                     function (error) {\r
1413                         console.error(error);\r
1414                     }\r
1415                 );\r
1416         }\r
1417 \r
1418 \r
1419         /*\r
1420         Callbaks functions\r
1421 \r
1422          */\r
1423         var updateProvStatusVnfCallbackFunction = function (response) {\r
1424             $scope.callbackResults = "";\r
1425             var color = FIELD.ID.COLOR_NONE;\r
1426             $scope.callbackStyle = {\r
1427                 "background-color": color\r
1428             };\r
1429             $scope.reloadRoute();\r
1430             /*\r
1431              * This 1/2 delay was only added to visually highlight the status\r
1432              * change. Probably not needed in the real application code.\r
1433              */\r
1434             $timeout(function () {\r
1435                 $scope.callbackResults = UtilityService.getCurrentTime()\r
1436                     + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;\r
1437                 if (response.isSuccessful) {\r
1438                     color = FIELD.ID.COLOR_8F8;\r
1439 \r
1440                 } else {\r
1441                     color = FIELD.ID.COLOR_F88;\r
1442                 }\r
1443                 $scope.callbackStyle = {\r
1444                     "background-color": color\r
1445                 };\r
1446             }, 500);\r
1447 \r
1448         };\r
1449 \r
1450         var createVnfCallbackFunction = function (response) {\r
1451             $scope.callbackResults = "";\r
1452             var color = FIELD.ID.COLOR_NONE;\r
1453             $scope.callbackStyle = {\r
1454                 "background-color": color\r
1455             };\r
1456 \r
1457             /*\r
1458              * This 1/2 delay was only added to visually highlight the status\r
1459              * change. Probably not needed in the real application code.\r
1460              */\r
1461             $timeout(function () {\r
1462                 $scope.callbackResults = UtilityService.getCurrentTime()\r
1463                     + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;\r
1464                 if (response.isSuccessful) {\r
1465                     color = FIELD.ID.COLOR_8F8;\r
1466                     $scope.reloadRoute();\r
1467                 } else {\r
1468                     color = FIELD.ID.COLOR_F88;\r
1469                 }\r
1470                 $scope.callbackStyle = {\r
1471                     "background-color": color\r
1472                 };\r
1473             }, 500);\r
1474 \r
1475 \r
1476         };\r
1477 \r
1478         var deleteOrResumeCallback = function (response) {\r
1479             $scope.callbackResults = "";\r
1480             var color = FIELD.ID.COLOR_NONE;\r
1481             $scope.callbackStyle = {\r
1482                 "background-color": color\r
1483             };\r
1484 \r
1485             /*\r
1486              * This 1/2 delay was only added to visually highlight the status\r
1487              * change. Probably not needed in the real application code.\r
1488              */\r
1489             $timeout(function () {\r
1490                 $scope.callbackResults = UtilityService.getCurrentTime()\r
1491                     + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;\r
1492                 if (response.isSuccessful) {\r
1493                     color = FIELD.ID.COLOR_8F8;\r
1494                     $scope.reloadRoute();\r
1495                 } else {\r
1496                     color = FIELD.ID.COLOR_F88;\r
1497                 }\r
1498                 $scope.callbackStyle = {\r
1499                     "background-color": color\r
1500                 };\r
1501             }, 500);\r
1502 \r
1503         };\r
1504 \r
1505         var createVfModuleCallbackFunction = function (response) {\r
1506             $scope.callbackResults = "";\r
1507             var color = FIELD.ID.COLOR_NONE;\r
1508             $scope.callbackStyle = {\r
1509                 "background-color": color\r
1510             };\r
1511 \r
1512             /*\r
1513              * This 1/2 delay was only added to visually highlight the status\r
1514              * change. Probably not needed in the real application code.\r
1515              */\r
1516             $timeout(function () {\r
1517                 $scope.callbackResults = UtilityService.getCurrentTime()\r
1518                     + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;\r
1519                 if (response.isSuccessful) {\r
1520                     color = FIELD.ID.COLOR_8F8;\r
1521                     $scope.reloadRoute();\r
1522                 } else {\r
1523                     color = FIELD.ID.COLOR_F88;\r
1524                 }\r
1525                 $scope.callbackStyle = {\r
1526                     "background-color": color\r
1527                 };\r
1528             }, 500);\r
1529 \r
1530         };\r
1531 \r
1532         var deleteServiceInstanceCallbackFunction = function (response) {\r
1533             $scope.callbackResults = "";\r
1534             var color = FIELD.ID.COLOR_NONE;\r
1535             $scope.callbackStyle = {\r
1536                 "background-color": color\r
1537             };\r
1538 \r
1539             /*\r
1540              * This 1/2 delay was only added to visually highlight the status\r
1541              * change. Probably not needed in the real application code.\r
1542              */\r
1543             $timeout(function () {\r
1544                 $scope.callbackResults = UtilityService.getCurrentTime()\r
1545                     + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;\r
1546                 if (response.isSuccessful) {\r
1547                     color = FIELD.ID.COLOR_8F8;\r
1548                     $location.path(COMPONENT.SERVICEMODELS_MODELS_SERVICES_PATH);\r
1549                 } else {\r
1550                     color = FIELD.ID.COLOR_F88;\r
1551                 }\r
1552                 $scope.callbackStyle = {\r
1553                     "background-color": color\r
1554                 };\r
1555             }, 500);\r
1556 \r
1557         };\r
1558 \r
1559         var createVolumeGroupCallbackFunction = function (response) {\r
1560             $scope.callbackResults = "";\r
1561             var color = FIELD.ID.COLOR_NONE;\r
1562             $scope.callbackStyle = {\r
1563                 "background-color": color\r
1564             };\r
1565 \r
1566             /*\r
1567              * This 1/2 delay was only added to visually highlight the status\r
1568              * change. Probably not needed in the real application code.\r
1569              */\r
1570             $timeout(function () {\r
1571                 $scope.callbackResults = UtilityService.getCurrentTime()\r
1572                     + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;\r
1573                 if (response.isSuccessful) {\r
1574                     color = FIELD.ID.COLOR_8F8;\r
1575                     $scope.reloadRoute();\r
1576                 } else {\r
1577                     color = FIELD.ID.COLOR_F88;\r
1578                 }\r
1579                 $scope.callbackStyle = {\r
1580                     "background-color": color\r
1581                 };\r
1582             }, 500);\r
1583 \r
1584 \r
1585         };\r
1586 \r
1587     });\r
1588 })();\r