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