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