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

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