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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * VID
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 /**
  22  * The Instantiation (or View/Edit) Controller controls the instantiation/removal of
  23  * deployable objects (Services, VNFs, VF-Modules, Networks, and Volume-Groups)
  24  */
  25 (function () {
  26         "use strict";
  27
  28         app.requires.push('ui.tree');
  29
  30         app.controller("InstantiationController", function ($scope, $route, $location, $timeout, COMPONENT, DataService, PropertyService, UtilityService, $http, vidService) {
  31
  32                 $scope.popup = new Object();
  33                 $scope.defaultBaseUrl = "";
  34                 $scope.responseTimeoutMsec = 60000;
  35                 $scope.properties = UtilityService.getProperties();
  36         $scope.init = function() {
  37
  38             /*
  39              * These 2 statements should be included in non-test code.
  40              */
  41                 // takes a default value, retrieves the prop value from the file system and sets it
  42                 var msecs = PropertyService.retrieveMsoMaxPollingIntervalMsec(1000);
  43                 PropertyService.setMsoMaxPollingIntervalMsec(msecs);
  44
  45                 // takes a default value, retrieves the prop value from the file system and sets it
  46                 var polls = PropertyService.retrieveMsoMaxPolls(7);
  47                 PropertyService.setMsoMaxPolls(polls);
  48
  49                 //PropertyService.setMsoBaseUrl("testmso");
  50                 PropertyService.setServerResponseTimeoutMsec(10000);
  51
  52             /*
  53              * Common parameters that shows an example of how the view edit screen
  54              * is expected to pass some common service instance values to the
  55              * popups.
  56              */
  57
  58 //            DataService.setSubscriberName("Mobility");
  59 //            DataService.setGlobalCustomerId("CUSTID12345")
  60 //            DataService.setServiceType("Mobility Type 1");
  61 //            DataService.setServiceInstanceName("Example Service Instance Name");
  62 //            DataService.setServiceName("Mobility Service 1");
  63 //            DataService.setServiceInstanceId("mmsc-test-service-instance");
  64 //            DataService.setServiceUuid("XXXX-YYYY-ZZZZ");
  65 //            DataService.setUserServiceInstanceName("USER_SERVICE_INSTANCE_NAME");
  66         }
  67
  68         //PropertyService.setMsoBaseUrl("testmso");
  69
  70                 $scope.convertModel = function(asdcModel) {
  71
  72                         if (!asdcModel) return undefined;
  73
  74                         var convertedAsdcModel = {
  75                                 "service": asdcModel.service,
  76                                 "networks": {},
  77                                 "vnfs": {}
  78                         };
  79
  80                         for (var networkUuid in asdcModel.networks) {
  81                                 var networkModel = asdcModel.networks[networkUuid];
  82                                 convertedAsdcModel.networks[networkModel.invariantUuid] = {};
  83                                 convertedAsdcModel.networks[networkModel.invariantUuid][networkModel.version] = networkModel;
  84                         }
  85
  86                         for (var vnfUuid in asdcModel.vnfs) {
  87                                 var vnfModel = asdcModel.vnfs[vnfUuid];
  88                                 convertedAsdcModel.vnfs[vnfModel.invariantUuid] = {};
  89                                 convertedAsdcModel.vnfs[vnfModel.invariantUuid][vnfModel.version] = {
  90                                                 "uuid": vnfModel.uuid,
  91                                                 "invariantUuid": vnfModel.invariantUuid,
  92                                                 "version": vnfModel.version,
  93                                                 "name": vnfModel.name,
  94                                                 "modelCustomizationName": vnfModel.modelCustomizationName,
  95                                                 "inputs": "",
  96                                                 "description": vnfModel.description,
  97                                                 "vfModules": {},
  98                                                 "volumeGroups": {}
  99                                 }
 100
 101                                 for (var vfModuleUuid in asdcModel.vnfs[vnfUuid].vfModules) {
 102                                         var vfModuleModel = asdcModel.vnfs[vnfUuid].vfModules[vfModuleUuid];
 103                                         convertedAsdcModel.vnfs[vnfModel.invariantUuid][vnfModel.version].vfModules[vfModuleModel.invariantUuid] = {};
 104                                         convertedAsdcModel.vnfs[vnfModel.invariantUuid][vnfModel.version].vfModules[vfModuleModel.invariantUuid][vfModuleModel.version] = vfModuleModel;
 105                                 }
 106
 107                                 for (var volumeGroupUuid in asdcModel.vnfs[vnfUuid].volumeGroups) {
 108                                         var volumeGroupModel = asdcModel.vnfs[vnfUuid].volumeGroups[volumeGroupUuid];
 109                                         convertedAsdcModel.vnfs[vnfModel.invariantUuid][vnfModel.version].volumeGroups[volumeGroupModel.invariantUuid] = {};
 110                                         convertedAsdcModel.vnfs[vnfModel.invariantUuid][vnfModel.version].volumeGroups[volumeGroupModel.invariantUuid][volumeGroupModel.version] = volumeGroupModel;
 111                                 }
 112                         }
 113                         console.log ("convertedAsdcModel: "); console.log (JSON.stringify ( convertedAsdcModel, null, 4 ) );
 114                         return convertedAsdcModel;
 115                 };
 116
 117                 $scope.service = {
 118                         "model": vidService.getModel(),
 119                         "modelByInvariantUuid": $scope.convertModel(vidService.getModel()),
 120                         "instance": vidService.getInstance()
 121                 };
 122
 123                 $scope.deleteNetwork = function(serviceObject, network) {
 124
 125                         console.log("Removing Network " + network.name);
 126
 127                         //Send delete network request to MSO
 128
 129                         //var networks = this.service.instance.networks;
 130
 131                         //networks.splice(networks.indexOf(network), 1);
 132
 133                         //Retrieve updated data from A&AI
 134             var serviceInstance = serviceObject.object;
 135
 136                         DataService.setInventoryItem(network);
 137                         DataService.setModelInfo(COMPONENT.NETWORK, $scope.service.model);
 138
 139                         DataService.setSubscriberName(serviceObject['subscriberName']);
 140                         DataService.setServiceType(serviceObject['serviceType']);
 141                         DataService.setServiceInstanceId(serviceInstance['service-instance-id']);
 142
 143                         DataService.setGlobalCustomerId(serviceObject['globalCustomerId']);
 144                         DataService.setServiceInstanceName($scope.service.instance.name);
 145
 146                         //DataService.setServiceName($scope.service.model.name);
 147
 148                         //DataService.setServiceUuid("XXXX-YYYY-ZZZZ");
 149                         //DataService.setUserServiceInstanceName("USER_SERVICE_INSTANCE_NAME");
 150
 151                         $scope.$broadcast("deleteComponent", {
 152                             componentId : COMPONENT.NETWORK,
 153                             callbackFunction : deleteCallbackFunction
 154                         });
 155                 };
 156
 157                 $scope.deleteService = function(serviceObject) {
 158
 159                         var serviceInstance = serviceObject.object;
 160
 161                         console.log("Removing Service " + $scope.service.instance.name);
 162
 163                         DataService.setInventoryItem(serviceInstance);
 164                         //DataService.setModelInfo(COMPONENT.SERVICE, $scope.service.model);
 165
 166                         DataService.setModelInfo(COMPONENT.SERVICE, {
 167                                 "modelInvariantId": $scope.service.model.service.invariantUuid,
 168                                 "modelVersion": $scope.service.model.service.version,
 169                                 "modelNameVersionId": $scope.service.model.service.uuid,
 170                                 "modelCustomizationName": "",
 171                                 "modelName": $scope.service.model.service.name,
 172                                 "inputs": ""
 173                         });
 174
 175                         DataService.setSubscriberName(serviceObject['subscriberName']);
 176                         DataService.setServiceType(serviceObject['serviceType']);
 177                         DataService.setServiceInstanceId(serviceInstance['service-instance-id']);
 178
 179                         DataService.setGlobalCustomerId(serviceObject['globalCustomerId']);
 180                         DataService.setServiceInstanceName($scope.service.instance.name);
 181
 182                         DataService.setServiceName($scope.service.model.service.name);
 183
 184                         DataService.setServiceUuid($scope.service.model.service.uuid);
 185                         //DataService.setUserServiceInstanceName("USER_SERVICE_INSTANCE_NAME");
 186
 187                         $scope.$broadcast("deleteComponent", {
 188                             componentId : COMPONENT.SERVICE,
 189                             callbackFunction : deleteServiceInstanceCallbackFunction
 190                         });
 191
 192                 };
 193
 194                 $scope.deleteVfModule = function(serviceObject, vfModule, vnf) {
 195
 196                         console.log("Removing VF-Module " + vfModule.name);
 197
 198             var serviceInstance = serviceObject.object;
 199
 200                         DataService.setInventoryItem(vfModule.object);
 201
 202                         var svcModel = $scope.service.modelByInvariantUuid;
 203                         var vnfModelInvariantUuid = vnf.object["persona-model-id"];
 204                         var vnfModelVersion = vnf.object["persona-model-version"];
 205                         if (svcModel != null && vnfModelInvariantUuid != null && vnfModelVersion != null )
 206                     {
 207                                 if ( ( UtilityService.hasContents(svcModel.vnfs) && UtilityService.hasContents(svcModel.vnfs[vnfModelInvariantUuid] ) ) &&
 208                                                 ( UtilityService.hasContents(svcModel.vnfs[vnfModelInvariantUuid][vnfModelVersion] ) ) ) {
 209                                         var vnfModel = svcModel.vnfs[vnfModelInvariantUuid][vnfModelVersion];
 210
 211                                         // volume groups don't have persona-model-id/version in a&ai.
 212                                         // Their persona-model-id/version is the one for the associated vfModule
 213
 214                                         var vfModuleInvariantUuid = vfModule.object["persona-model-id"];
 215                                         var vfModuleModelVersion = vfModule.object["persona-model-version"];
 216
 217                                         if ( UtilityService.hasContents(vnfModel) && UtilityService.hasContents(vnfModel.vfModules) && UtilityService.hasContents(vfModuleInvariantUuid)  &&  UtilityService.hasContents(vfModuleModelVersion) )
 218                                         {
 219                                                 var vfModelGroupModel = vnfModel.vfModules[vfModuleInvariantUuid][vfModuleModelVersion];
 220
 221                                                 var vfModeluuid = vfModelGroupModel.uuid;
 222                                                 if (vfModeluuid == null)
 223                                                         vfModeluuid = "";
 224
 225                                                 var vnfModelCustomizationName = vnfModel.modelCustomizationName;
 226                                                 if (vnfModelCustomizationName == null)
 227                                                         vnfModelCustomizationName = "";
 228
 229                                                 var vfModelName = vfModelGroupModel.name;
 230                                                 if (vfModelName == null)
 231                                                         vfModelName = "";
 232
 233                                                 var vfModelVersionID = vfModule.object['vf-module-id'];
 234                                                 if (vfModelVersionID == null)
 235                                                         vfModelVersionID = "";
 236
 237                                                 DataService.setModelInfo(COMPONENT.VF_MODULE, {
 238                                                         "modelInvariantId": vfModuleInvariantUuid,
 239                                                         "modelVersion": vfModuleModelVersion,
 240                                                         "modelNameVersionId": vfModeluuid,
 241                                                         "modelCustomizationName": vnfModelCustomizationName,
 242                                                         "modelName": vfModelName,
 243                                                         "inputs": ""
 244                                                 });
 245
 246                                                 DataService.setVnfInstanceId(vnf.object['vnf-id']);
 247                                                 DataService.setVfModuleInstanceId(vfModelVersionID);
 248
 249                                                 DataService.setSubscriberName(serviceObject['subscriberName']);
 250                                                 DataService.setServiceType(serviceObject['serviceType']);
 251                                                 DataService.setServiceInstanceId(serviceInstance['service-instance-id']);
 252
 253                                                 DataService.setGlobalCustomerId(serviceObject['globalCustomerId']);
 254                                                 DataService.setServiceInstanceName($scope.service.instance.name);
 255
 256                                                 DataService.setServiceName($scope.service.model.service.name);
 257
 258                                                 DataService.setServiceUuid($scope.service.model.service.uuid);
 259                                                 //DataService.setUserServiceInstanceName("USER_SERVICE_INSTANCE_NAME");
 260
 261                                                 $scope.$broadcast("deleteComponent", {
 262                                                     componentId : COMPONENT.VF_MODULE,
 263                                                     callbackFunction : deleteCallbackFunction
 264                                                 });
 265
 266                                                 return;
 267                                         }
 268
 269                                 }
 270                     }
 271
 272                    console.log("Removing VNF " + vnf.name + " could not proceed due to missing ASDC model information.");
 273
 274
 275                         //Retrieve updated data from A&AI
 276                 };
 277
 278                 $scope.deleteVnf = function(serviceObject, vnf) {
 279
 280                         console.log("Removing VNF " + vnf.name);
 281
 282                         var serviceInstance = serviceObject.object;
 283
 284                         DataService.setInventoryItem(vnf.object);
 285
 286                         var vnftype = vnf.object['vnf-type'];
 287                         if (vnftype == null)
 288                                 vnftype = "";
 289                         else
 290                         {
 291                                 var n = vnftype.search("/");
 292                                 if (n >= 0)
 293                                         vnftype = vnftype.substring(n+1);
 294                         }
 295
 296
 297                         var svcModel = $scope.service.modelByInvariantUuid;
 298                         var vnfModelInvariantUuid = vnf.object["persona-model-id"];
 299                         var vnfModelVersion = vnf.object["persona-model-version"];
 300                         if (svcModel != null && vnfModelInvariantUuid != null && vnfModelVersion != null )
 301                     {
 302
 303                                 console.log ( "vnf models: "); console.log ( JSON.stringify ($scope.service.modelByInvariantUuid.vnfs, null, 4) );
 304
 305                                 var vnfModel = $scope.service.modelByInvariantUuid.vnfs[vnfModelInvariantUuid][vnfModelVersion];
 306                                 if (vnfModel == null)
 307                                         {
 308                                                 DataService.setModelInfo(COMPONENT.VNF, {
 309                                                         "modelInvariantId": vnfModelInvariantUuid,
 310                                                         "modelVersion": vnfModelVersion,
 311                                                         "modelNameVersionId": "",
 312                                                         "modelCustomizationName": vnftype,
 313                                                         "modelName": "",
 314                                                         "inputs": ""
 315                                                 });
 316                                         }
 317                                 else
 318                                         {
 319                                                 DataService.setModelInfo(COMPONENT.VNF, {
 320                                                         "modelInvariantId": vnfModelInvariantUuid,
 321                                                         "modelVersion": vnfModelVersion,
 322                                                         "modelNameVersionId": vnfModel.uuid,
 323                                                         "modelCustomizationName": vnftype,
 324                                                         "modelName": vnfModel.name,
 325                                                         "inputs": ""
 326                                                 });
 327                                         }
 328                     }
 329                         else
 330                         {
 331                            console.log("Removing VNF name = " + vnf.name + " didn't get the correponding model details so sending empty model values to MSO!");
 332                            DataService.setModelInfo(COMPONENT.VNF, {
 333                                         "modelInvariantId": "",
 334                                         "modelVersion": "",
 335                                         "modelNameVersionId": "",
 336                                         "modelCustomizationName": vnftype,
 337                                         "modelName": "",
 338                                         "inputs": ""
 339                                 });
 340                         }
 341
 342                         DataService.setVnfInstanceId(vnf.object['vnf-id']);
 343
 344                         DataService.setSubscriberName(serviceObject['subscriberName']);
 345                         DataService.setServiceType(serviceObject['serviceType']);
 346                         DataService.setServiceInstanceId(serviceInstance['service-instance-id']);
 347
 348                         DataService.setGlobalCustomerId(serviceObject['globalCustomerId']);
 349                         DataService.setServiceInstanceName($scope.service.instance.name);
 350
 351                         DataService.setServiceName($scope.service.model.service.name);
 352
 353                         DataService.setServiceUuid($scope.service.model.service.uuid);
 354                         //DataService.setUserServiceInstanceName("USER_SERVICE_INSTANCE_NAME");
 355
 356                         $scope.$broadcast("deleteComponent", {
 357                             componentId : COMPONENT.VNF,
 358                             callbackFunction : deleteCallbackFunction
 359                         });
 360
 361                 };
 362
 363                 /*
 364                 $scope.deleteVnf = function(serviceObject, vnf) {
 365
 366                         console.log("Removing VNF " + vnf.name);
 367
 368                         //Send delete VF-Module request to MSO
 369
 370                         var svcModel = $scope.service.modelByInvariantUuid;
 371                         var vnfModelInvariantUuid = vnf.object["persona-model-id"];
 372                         var vnfModelVersion = vnf.object["persona-model-version"];
 373                         console.log ( "vnf models: "); console.log ( JSON.stringify ($scope.service.modelByInvariantUuid.vnfs, null, 4) );
 374
 375                         DataService.setInventoryItem(vnf);
 376
 377                         var vnfModel = $scope.service.modelByInvariantUuid.vnfs[vnfModelInvariantUuid][vnfModelVersion];
 378
 379                         DataService.setModelInfo(COMPONENT.VNF, {
 380                                 "modelInvariantId": vnfModelInvariantUuid,
 381                                 "modelVersion": vnfModelVersion,
 382                                 "modelNameVersionId": vnfModel.uuid,
 383                                 "modelCustomizationName": vnfModel.modelCustomizationName,
 384                                 "modelName": vnfModel.name,
 385                                 "inputs": vnfModel.inputs
 386                         });
 387
 388                         DataService.setSubscriberName(serviceObject['globalCustomerId']);
 389                         DataService.setServiceType(serviceObject['serviceType']);
 390                         DataService.setServiceInstanceId(serviceObject['service-instance-id']);
 391
 392                         DataService.setGlobalCustomerId(serviceObject['globalCustomerId']);
 393                         DataService.setServiceInstanceName($scope.service.instance.name);
 394
 395                         DataService.setServiceName(vnf.name);
 396
 397                         DataService.setServiceUuid($scope.service.model.service.uuid);
 398                         //DataService.setUserServiceInstanceName("USER_SERVICE_INSTANCE_NAME");
 399
 400                         $scope.$broadcast("deleteComponent", {
 401                             componentId : COMPONENT.VNF,
 402                             callbackFunction : deleteCallbackFunction
 403                         });
 404
 405                         //var vnfs = this.service.instance.vnfs;
 406
 407                         //vnfs.splice(vnfs.indexOf(vnf), 1);
 408
 409                         //Retrieve updated data from A&AI
 410                 };*/
 411
 412                 $scope.deleteVolumeGroup = function(serviceObject, vnf, vfModule, volumeGroup) {
 413
 414                         console.log("Removing Volume Group " + volumeGroup.name);
 415                         var haveModel = false;
 416                         var svcModel = $scope.service.modelByInvariantUuid;
 417
 418                         var vnfModelInvariantUuid = vnf.object["persona-model-id"];
 419                         var vnfModelVersion = vnf.object["persona-model-version"];
 420
 421                         if ( ( UtilityService.hasContents(vnfModelInvariantUuid) ) && (UtilityService.hasContents(vnfModelVersion) ) ) {
 422                                 if ( UtilityService.hasContents(svcModel) && UtilityService.hasContents($scope.service.modelByInvariantUuid.vnfs) ) {
 423                                         //console.log ( "vnf models "); console.log (JSON.stringify ($scope.service.modelByInvariantUuid.vnfs, null, 4) );
 424                                         if ( ( UtilityService.hasContents($scope.service.modelByInvariantUuid.vnfs[vnfModelInvariantUuid] ) ) &&
 425                                                         ( UtilityService.hasContents($scope.service.modelByInvariantUuid.vnfs[vnfModelInvariantUuid][vnfModelVersion] ) ) ) {
 426                                                 var vnfModel = $scope.service.modelByInvariantUuid.vnfs[vnfModelInvariantUuid][vnfModelVersion];
 427
 428                                                 // volume groups don't have persona-model-id/version in a&ai.
 429                                                 // Their persona-model-id/version is the one for the associated vfModule
 430
 431                                                 var vfModuleInvariantUuid = vfModule.object["persona-model-id"];
 432                                                 var vfModuleModelVersion = vfModule.object["persona-model-version"];
 433
 434                                                 if ( UtilityService.hasContents(vnfModel.volumeGroups) && UtilityService.hasContents(vfModuleInvariantUuid)  &&  UtilityService.hasContents(vfModuleModelVersion) ) {
 435
 436                                                         if ( ( UtilityService.hasContents (vnfModel.volumeGroups[vfModuleInvariantUuid]) ) &&
 437                                                                         (UtilityService.hasContents (vnfModel.volumeGroups[vfModuleInvariantUuid][vfModuleModelVersion]) ) ) {
 438                                                                 var volGroupModel = vnfModel.volumeGroups[vfModuleInvariantUuid][vfModuleModelVersion];
 439
 440                                                                 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
 441                                                                         "modelInvariantId": vfModuleInvariantUuid,
 442                                                                         "modelVersion": vfModuleModelVersion,
 443                                                                         "modelNameVersionId": volGroupModel.uuid,
 444                                                                         "modelCustomizationName": vnfModel.modelCustomizationName,
 445                                                                         "modelName": volGroupModel.name,
 446                                                                         "inputs": ""
 447                                                                 });
 448                                                                 haveModel = true;
 449
 450                                                         }
 451                                                 }
 452                                         }
 453                                 }
 454                         }
 455                         if ( !haveModel ) {
 456                                 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
 457                                         "modelInvariantId": "",
 458                                         "modelVersion": "",
 459                                         "modelNameVersionId": "",
 460                                         "modelCustomizationName": "",
 461                                         "modelName": "",
 462                                         "inputs": ""
 463                                 });
 464                         }
 465
 466                         var serviceInstance = serviceObject.object;
 467
 468             DataService.setInventoryItem(volumeGroup.object);
 469
 470                         DataService.setSubscriberName(serviceObject['subscriberName']);
 471                         DataService.setServiceType(serviceObject['serviceType']);
 472                         DataService.setServiceInstanceId(serviceInstance['service-instance-id']);
 473
 474                         DataService.setGlobalCustomerId(serviceObject['globalCustomerId']);
 475                         DataService.setServiceInstanceName($scope.service.instance.name);
 476
 477                         DataService.setServiceName($scope.service.model.service.name);
 478
 479                         DataService.setServiceUuid($scope.service.model.service.uuid);
 480                         DataService.setVnfInstanceId(vnf.nodeId);
 481                         DataService.setVolumeGroupInstanceId(volumeGroup.nodeId);
 482
 483                         //DataService.setUserServiceInstanceName("USER_SERVICE_INSTANCE_NAME");
 484
 485                         $scope.$broadcast("deleteComponent", {
 486                             componentId : COMPONENT.VOLUME_GROUP,
 487                             callbackFunction : deleteCallbackFunction
 488                         });
 489                 };
 490
 491                 $scope.deleteVnfVolumeGroup = function(serviceObject, vnf, volumeGroup) {
 492
 493                         console.log("Removing Volume Group " + volumeGroup.name);
 494             var serviceInstance = serviceObject.object;
 495
 496             DataService.setInventoryItem(volumeGroup.object);
 497
 498                         var svcModel = $scope.service.modelByInvariantUuid;
 499                         var vnfModelInvariantUuid = vnf.object["persona-model-id"];
 500                         var vnfModelVersion = vnf.object["persona-model-version"];
 501                         var vnfModel = null;
 502
 503                         var volGroupModelInvariantUuid = null;
 504                         var volGroupModelVersion = null;
 505
 506                         // send an empty model by default since model is not required for deletes
 507                         DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {});
 508
 509                         if ( (volumeGroup.object != null) && ( volumeGroup.object["persona-model-id"] != null ) &&
 510                                         (volumeGroup.object["persona-model-version"] != null) ) {
 511
 512                                 volGroupModelInvariantUuid = volumeGroup.object["persona-model-id"];
 513                                 volGroupModelVersion = volumeGroup.object["persona-model-version"];
 514
 515                                 if (svcModel != null && vnfModelInvariantUuid != null && vnfModelVersion != null ) {
 516                                         console.log ( "vnf models: "); console.log ( JSON.stringify ($scope.service.modelByInvariantUuid.vnfs, null, 4) );
 517                                         if ( ($scope.service.modelByInvariantUuid.vnfs[vnfModelInvariantUuid] != null) &&
 518                                                         ($scope.service.modelByInvariantUuid.vnfs[vnfModelInvariantUuid][vnfModelVersion]) != null ) {
 519
 520                                                 vnfModel = $scope.service.modelByInvariantUuid.vnfs[vnfModelInvariantUuid][vnfModelVersion];
 521                                                 if ( (vnfModel.volumeGroups != null) && ( vnfModel.volumeGroups[volGroupModelInvariantUuid] != null )
 522                                                                 && ( vnfModel.volumeGroups[volGroupModelInvariantUuid][volGroupModelVersion] != null ) ) {
 523
 524                                                         var volumeGroupModel = vnfModel.volumeGroups[volGroupModelInvariantUuid][volGroupModelVersion];
 525
 526                                                         DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
 527                                                                 "modelInvariantId": volumeGroupModel.invariantUuid,
 528                                                                 "modelVersion": volumeGroupModel.version,
 529                                                                 "modelNameVersionId": volumeGroupModel.uuid,
 530                                                                 "modelName": volumeGroupModel.name,
 531                                                                 "modelCustomizationName": volumeGroupModel.modelCustomizationName,
 532                                                                 "inputs": ""
 533                                                         });
 534                                                 }
 535                                         }
 536                             }
 537                         }
 538
 539                         DataService.setVnfInstanceId(vnf.object['vnf-id']);
 540
 541                         DataService.setSubscriberName(serviceObject['subscriberName']);
 542                         DataService.setServiceType(serviceObject['serviceType']);
 543                         DataService.setServiceInstanceId(serviceInstance['service-instance-id']);
 544
 545                         DataService.setGlobalCustomerId(serviceObject['globalCustomerId']);
 546                         DataService.setServiceInstanceName($scope.service.instance.name);
 547
 548                         DataService.setServiceName($scope.service.model.service.name);
 549
 550                         DataService.setServiceUuid($scope.service.model.service.uuid);
 551                         DataService.setVnfInstanceId(vnf.nodeId);
 552                         DataService.setVolumeGroupInstanceId(volumeGroup.nodeId);
 553
 554                         //DataService.setUserServiceInstanceName("USER_SERVICE_INSTANCE_NAME");
 555
 556                         $scope.$broadcast("deleteComponent", {
 557                             componentId : COMPONENT.VOLUME_GROUP,
 558                             callbackFunction : deleteCallbackFunction
 559                         });
 560                 };
 561
 562                 $scope.describeNetwork = function(serviceObject, networkObject) {
 563                         var serviceInstance = serviceObject.object;
 564                         var network = networkObject.object;
 565
 566                         //Display popup with additional network information
 567                         DataService.setNetworkInstanceId(network['network-id']);
 568                         DataService.setInventoryItem(network);
 569                         //DataService.setModelInfo(network['network-id'], network);
 570
 571                         DataService.setSubscriberName(serviceObject['subscriber-name']);
 572                         DataService.setServiceType(serviceObject['serviceType']);
 573                         DataService.setServiceInstanceId(serviceInstance['service-instance-id']);
 574
 575                         //DataService.setVnfInstanceId("Testing");
 576                         $scope.$broadcast("showComponentDetails", {
 577                             componentId : COMPONENT.NETWORK
 578                         });
 579                 };
 580
 581                 // for service instance id - no need for this!
 582                 $scope.describeService = function(serviceObject) {
 583                         var serviceInstance = serviceObject.object;
 584
 585                         DataService.setInventoryItem(serviceInstance);
 586                         //DataService.setModelInfo(serviceInstance['service-instance-id'], serviceInstance);
 587
 588                         DataService.setSubscriberName(serviceObject['subscriberName']);
 589                         DataService.setServiceType(serviceObject['serviceType']);
 590                         DataService.setServiceInstanceId(serviceInstance['service-instance-id']);
 591
 592                         //Display popup with additional service information
 593                         $scope.$broadcast("showComponentDetails", {
 594                             componentId : COMPONENT.SERVICE
 595                         });
 596
 597                 };
 598
 599                 $scope.describeVfModule = function(serviceObject, vfModuleObject) {
 600                         var serviceInstance = serviceObject.object;
 601                         var vfModule = vfModuleObject.object;
 602
 603                         //Display popup with additional VF-Module information
 604                         DataService.setVfModuleInstanceId(vfModule['vf-module-id']);
 605                         DataService.setInventoryItem(vfModule);
 606                         //DataService.setModelInfo(vfModule['vf-module-id'], vfModule);
 607
 608                         DataService.setSubscriberName(serviceObject['subscriberName']);
 609                         DataService.setServiceType(serviceObject['serviceType']);
 610                         DataService.setServiceInstanceId(serviceInstance['service-instance-id']);
 611
 612                         $scope.$broadcast("showComponentDetails", {
 613                             componentId : COMPONENT.VF_MODULE
 614                         });
 615                 };
 616
 617                 $scope.describeVnf = function(serviceObject, vnfObject) {
 618                         var serviceInstance = serviceObject.object;
 619                         var vnf = vnfObject.object;
 620
 621                         //Display popup with additional VNF information
 622                         DataService.setVnfInstanceId(vnf['vnf-id']);
 623                         DataService.setInventoryItem(vnf);
 624                         //DataService.setModelInfo(vnf['vnf-id'], vnf);
 625
 626                         DataService.setSubscriberName(serviceObject['subscriberName']);
 627                         DataService.setServiceType(serviceObject['serviceType']);
 628                         DataService.setServiceInstanceId(serviceInstance['service-instance-id']);
 629
 630                         $scope.$broadcast("showComponentDetails", {
 631                             componentId : COMPONENT.VNF
 632                         });
 633                 };
 634
 635                 $scope.describeVolumeGroup = function(serviceObject, volumeGroupObject) {
 636                         var serviceInstance = serviceObject.object;
 637                         var volumeGroup = volumeGroupObject.object;
 638
 639                         DataService.setVolumeGroupInstanceId(volumeGroup['volume-group-id']);
 640                         DataService.setInventoryItem(volumeGroup);
 641                         DataService.setModelInfo(volumeGroup['volume-group-id'], volumeGroup);
 642
 643                         DataService.setSubscriberName(serviceObject['subscriberName']);
 644                         DataService.setServiceType(serviceObject['serviceType']);
 645                         DataService.setServiceInstanceId(serviceInstance['service-instance-id']);
 646
 647                         //Display popup with additional Volume Group information
 648                         //DataService.setVnfInstanceId("Testing");
 649                         $scope.$broadcast("showComponentDetails", {
 650                             componentId : COMPONENT.VOLUME_GROUP
 651                         });
 652                 };
 653
 654                 $scope.addNetworkInstance = function(network) {
 655                         console.log("Unsupported in 1610: Adding Network instance of type " + network.name + " to service instance" + this.service.instance.name);
 656                 };
 657
 658                 $scope.addVnfInstance = function(vnf) {
 659                         //console.log ("addVnfInstance invoked VNF="); console.log (JSON.stringify (vnf,null,4));
 660
 661                         DataService.setSubscriberName($scope.service.instance.subscriberName);
 662                         DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
 663                         DataService.setServiceType($scope.service.instance.serviceType);
 664                         DataService.setServiceInstanceName($scope.service.instance.name);
 665                         DataService.setServiceInstanceId($scope.service.instance.id);
 666                         DataService.setServiceName($scope.service.model.service.name);
 667
 668                         DataService.setModelInfo(COMPONENT.VNF, {
 669                                 "modelType": "vnf",
 670                                 "modelInvariantId": vnf.invariantUuid,
 671                                 "modelVersion": vnf.version,
 672                                 "modelNameVersionId": vnf.uuid,
 673                                 "modelName": vnf.name,
 674                                 "modelCustomizationName": vnf.modelCustomizationName,
 675                                 "inputs": ""
 676                         });
 677
 678                         DataService.setModelInstanceName($scope.service.model.service.name);
 679
 680                         DataService.setModelInfo(COMPONENT.SERVICE, {
 681                                 "modelInvariantId": $scope.service.model.service.invariantUuid,
 682                                 "modelVersion": $scope.service.model.service.version,
 683                                 "modelNameVersionId": $scope.service.model.service.uuid,
 684                                 "modelName": $scope.service.model.service.name,
 685                                 "inputs": ""
 686                         });
 687
 688                         $scope.$broadcast("createComponent", {
 689                             componentId : COMPONENT.VNF,
 690                             callbackFunction : createVnfCallbackFunction
 691                         });
 692                 };
 693
 694                 $scope.addVfModuleInstance = function(vnfInstance, vfModuleModel) {
 695
 696                         DataService.setSubscriberName($scope.service.instance.subscriberName);
 697                         DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
 698                         DataService.setServiceType($scope.service.instance.serviceType);
 699                         DataService.setServiceInstanceName($scope.service.instance.name);
 700                         DataService.setServiceInstanceId($scope.service.instance.id);
 701                         DataService.setServiceName($scope.service.model.service.name);
 702
 703                         var vnfModelInvariantUuid = vnfInstance.object["persona-model-id"];
 704                         var vnfModelVersion = vnfInstance.object["persona-model-version"];
 705                         var vnfModel = $scope.service.modelByInvariantUuid.vnfs[vnfModelInvariantUuid][vnfModelVersion];
 706
 707                         var availableVolumeGroupList = [];
 708                         angular.forEach(vnfInstance["availableVolumeGroups"], function(volumeGroupInstance, key) {
 709                                 availableVolumeGroupList.push({"instance": volumeGroupInstance});
 710                         });
 711
 712                         if (vfModuleModel.volumeGroupAllowed) {
 713                                 DataService.setAvailableVolumeGroupList(availableVolumeGroupList);
 714                         }
 715
 716                         DataService.setModelInfo(COMPONENT.SERVICE, {
 717                                 "modelInvariantId": $scope.service.model.service.invariantUuid,
 718                                 "modelVersion": $scope.service.model.service.version,
 719                                 "modelNameVersionId": $scope.service.model.service.uuid,
 720                                 "modelName": $scope.service.model.service.name,
 721                                 "inputs": ""
 722                         });
 723
 724                         DataService.setVnfInstanceId(vnfInstance.object["vnf-id"]);
 725
 726                         DataService.setModelInfo(COMPONENT.VNF, {
 727                                 "modelInvariantId": vnfModel.invariantUuid,
 728                                 "modelVersion": vnfModel.version,
 729                                 "modelNameVersionId": vnfModel.uuid,
 730                                 "modelName": vnfModel.name,
 731                                 "modelCustomizationName": vnfModel.modelCustomizationName,
 732                                 "inputs": ""
 733                         });
 734
 735                         DataService.setModelInfo(COMPONENT.VF_MODULE, {
 736                                 "modelInvariantId": vfModuleModel.invariantUuid,
 737                                 "modelVersion": vfModuleModel.version,
 738                                 "modelNameVersionId": vfModuleModel.uuid,
 739                                 "modelName": vfModuleModel.name,
 740                                 "inputs": ""
 741                         });
 742
 743                         $scope.$broadcast("createComponent", {
 744                             componentId : COMPONENT.VF_MODULE,
 745                             callbackFunction : createVfModuleCallbackFunction
 746                         });
 747
 748                 };
 749
 750                 $scope.addVolumeGroupInstance = function(vnfInstance, volumeGroupModel) {
 751
 752                         DataService.setSubscriberName($scope.service.instance.subscriberName);
 753                         DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
 754                         DataService.setServiceType($scope.service.instance.serviceType);
 755                         DataService.setServiceInstanceName($scope.service.instance.name);
 756                         DataService.setServiceInstanceId($scope.service.instance.id);
 757                         DataService.setServiceName($scope.service.model.service.name);
 758
 759                         DataService.setModelInfo(COMPONENT.SERVICE, {
 760                                 "modelInvariantId": $scope.service.model.service.invariantUuid,
 761                                 "modelVersion": $scope.service.model.service.version,
 762                                 "modelNameVersionId": $scope.service.model.service.uuid,
 763                                 "modelName": $scope.service.model.service.name,
 764                                 "inputs": ""
 765                         });
 766
 767                         DataService.setVnfInstanceId(vnfInstance.object["vnf-id"]);
 768
 769                         var vnfModelInvariantUuid = vnfInstance.object["persona-model-id"];
 770                         var vnfModelVersion = vnfInstance.object["persona-model-version"];
 771                         var vnfModel = $scope.service.modelByInvariantUuid.vnfs[vnfModelInvariantUuid][vnfModelVersion];
 772
 773                         DataService.setModelInfo(COMPONENT.VNF, {
 774                                 "modelInvariantId": vnfModel.invariantUuid,
 775                                 "modelVersion": vnfModel.version,
 776                                 "modelNameVersionId": vnfModel.uuid,
 777                                 "modelName": vnfModel.name,
 778                                 "modelCustomizationName": vnfModel.modelCustomizationName,
 779                                 "inputs": ""
 780                         });
 781
 782                         DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
 783                                 "modelInvariantId": volumeGroupModel.invariantUuid,
 784                                 "modelVersion": volumeGroupModel.version,
 785                                 "modelNameVersionId": volumeGroupModel.uuid,
 786                                 "modelName": volumeGroupModel.name,
 787                                 "inputs": ""
 788                         });
 789
 790                         $scope.$broadcast("createComponent", {
 791                             componentId : COMPONENT.VOLUME_GROUP,
 792                             callbackFunction : createVolumeGroupCallbackFunction
 793                         });
 794                 };
 795
 796                 $scope.attachVolumeGroupInstance = function(vfModuleInstance, volumeGroupInstance) {
 797
 798                         var vnfInstance = this.vnf;
 799                         var vnfModelInvariantUuid = vnfInstance.object["persona-model-id"];
 800                         var vnfModelVersion = vnfInstance.object["persona-model-version"];
 801                         var vnfModel = $scope.service.modelByInvariantUuid.vnfs[vnfModelInvariantUuid][vnfModelVersion];
 802
 803                         var vfModuleModelInvariantUuid = vfModuleInstance.object["persona-model-id"];
 804                         var vfModuleVersion = vfModuleInstance.object["persona-model-version"];
 805                         var vfModuleModel = vnfModel.vfModules[vfModuleModelInvariantUuid][vfModuleVersion];
 806
 807                         var volumeGroupModelInvariantUuid = volumeGroupInstance.object["persona-model-id"];
 808                         var volumeGroupModelVersion = volumeGroupInstance.object["persona-model-version"];
 809                         var volumeGroupModel = vnfModel.volumeGroups[volumeGroupModelInvariantUuid][volumeGroupModelVersion];
 810
 811                         if (vfModuleModel.uuid != volumeGroupModel.uuid) alert("Cannot attach this volume group to this VF module (models do not match)");
 812
 813                         DataService.setSubscriberName($scope.service.instance.subscriberName);
 814                         DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
 815                         DataService.setServiceName($scope.service.model.name);
 816                         DataService.setServiceType($scope.service.instance.serviceType);
 817                         DataService.setServiceInstanceName($scope.service.instance.name);
 818                         DataService.setServiceInstanceId($scope.service.instance.id);
 819
 820                         DataService.setModelInfo(COMPONENT.SERVICE, {
 821                                 "modelInvariantId": $scope.service.model.service.invariantUuid,
 822                                 "modelVersion": $scope.service.model.service.version,
 823                                 "modelNameVersionId": $scope.service.model.service.uuid,
 824                                 "modelName": $scope.service.model.service.name,
 825                                 "inputs": ""
 826                         });
 827
 828                         DataService.setVnfInstanceId(vnfInstance.object["vnf-id"]);
 829
 830                         DataService.setModelInfo(COMPONENT.VNF, {
 831                                 "modelInvariantId": vnfModel.invariantUuid,
 832                                 "modelVersion": vnfModel.version,
 833                                 "modelNameVersionId": vnfModel.uuid,
 834                                 "modelName": vnfModel.name,
 835                                 "modelCustomizationName": vnfModel.modelCustomizationName,
 836                                 "inputs": ""
 837                         });
 838
 839                         DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
 840                                 "modelInvariantId": volumeGroupModel.invariantUuid,
 841                                 "modelVersion": volumeGroupModel.version,
 842                                 "modelNameVersionId": volumeGroupModel.uuid,
 843                                 "modelName": volumeGroupModel.name,
 844                                 "inputs": ""
 845                         });
 846
 847                         $scope.$broadcast("createComponent", {
 848                             componentId : COMPONENT.VOLUME_GROUP,
 849                             callbackFunction : createVolumeGroupCallbackFunction
 850                         });
 851                         /*
 852                          * Code to manipulate the angular ui-tree
 853                         var volumeGroups = this.vnf.volumeGroups;
 854                         volumeGroups.splice(volumeGroups.indexOf(volumeGroup), 1);
 855                         vfModule.volumeGroups.push(volumeGroup);
 856                         */
 857                 };
 858
 859                 $scope.resetProgress = function() {
 860                         $scope.percentProgress = 0;
 861                         $scope.progressClass = "progress-bar progress-bar-info";
 862                 };
 863
 864                 $scope.setProgress = function(percentProgress) {
 865                         percentProgress = parseInt(percentProgress);
 866                         if (percentProgress >= 100) {
 867                                 $scope.progressClass = "progress-bar progress-bar-success";
 868                         }
 869
 870                         if (percentProgress < $scope.percentProgress) {
 871                                 return;
 872                         }
 873
 874                         $scope.percentProgress = percentProgress;
 875                         $scope.progressWidth = {width: percentProgress + "%"};
 876                         if (percentProgress >= 5) {
 877                                 $scope.progressText =  percentProgress + " %";
 878                         } else {
 879                                 // Hidden since color combination is barely visible when progress portion is narrow.
 880                                 $scope.progressText = "";
 881                         }
 882                 };
 883
 884                 $scope.reloadRoute = function() {
 885                         $route.reload();
 886                 }
 887
 888                 var createVnfCallbackFunction = function(response) {
 889                         $scope.callbackResults = "";
 890                         var color = "none";
 891                         $scope.callbackStyle = {
 892                                         "background-color" : color
 893                         };
 894
 895                         /*
 896                          * This 1/2 delay was only added to visually highlight the status
 897                          * change. Probably not needed in the real application code.
 898                          */
 899                         $timeout(function() {
 900                                 $scope.callbackResults = UtilityService.getCurrentTime()
 901                                 + " isSuccessful: " + response.isSuccessful;
 902                                 if (response.isSuccessful) {
 903                                         color = "#8F8";
 904                                         $scope.reloadRoute();
 905                                 } else {
 906                                         color = "#F88";
 907                                 }
 908                                 $scope.callbackStyle = {
 909                                                 "background-color" : color
 910                                 };
 911                         }, 500);
 912
 913
 914
 915                 };
 916
 917                 var deleteCallbackFunction = function(response) {
 918                         $scope.callbackResults = "";
 919                         var color = "none";
 920                         $scope.callbackStyle = {
 921                                         "background-color" : color
 922                         };
 923
 924                         /*
 925                          * This 1/2 delay was only added to visually highlight the status
 926                          * change. Probably not needed in the real application code.
 927                          */
 928                         $timeout(function() {
 929                                 $scope.callbackResults = UtilityService.getCurrentTime()
 930                                 + " isSuccessful: " + response.isSuccessful;
 931                                 if (response.isSuccessful) {
 932                                         color = "#8F8";
 933                                         $scope.reloadRoute();
 934                                 } else {
 935                                         color = "#F88";
 936                                 }
 937                                 $scope.callbackStyle = {
 938                                                 "background-color" : color
 939                                 };
 940                         }, 500);
 941
 942                 };
 943
 944                 var createVfModuleCallbackFunction = function(response) {
 945                         $scope.callbackResults = "";
 946                         var color = "none";
 947                         $scope.callbackStyle = {
 948                                         "background-color" : color
 949                         };
 950
 951                         /*
 952                          * This 1/2 delay was only added to visually highlight the status
 953                          * change. Probably not needed in the real application code.
 954                          */
 955                         $timeout(function() {
 956                                 $scope.callbackResults = UtilityService.getCurrentTime()
 957                                 + " isSuccessful: " + response.isSuccessful;
 958                                 if (response.isSuccessful) {
 959                                         color = "#8F8";
 960                                         $scope.reloadRoute();
 961                                 } else {
 962                                         color = "#F88";
 963                                 }
 964                                 $scope.callbackStyle = {
 965                                                 "background-color" : color
 966                                 };
 967                         }, 500);
 968
 969                 };
 970
 971                 var deleteServiceInstanceCallbackFunction = function(response) {
 972                         $scope.callbackResults = "";
 973                         var color = "none";
 974                         $scope.callbackStyle = {
 975                                         "background-color" : color
 976                         };
 977
 978                         /*
 979                          * This 1/2 delay was only added to visually highlight the status
 980                          * change. Probably not needed in the real application code.
 981                          */
 982                         $timeout(function() {
 983                                 $scope.callbackResults = UtilityService.getCurrentTime()
 984                                 + " isSuccessful: " + response.isSuccessful;
 985                                 if (response.isSuccessful) {
 986                                         color = "#8F8";
 987                                         $location.path("/instances/services")
 988                                 } else {
 989                                         color = "#F88";
 990                                 }
 991                                 $scope.callbackStyle = {
 992                                                 "background-color" : color
 993                                 };
 994                         }, 500);
 995
 996                 };
 997
 998                 var createVolumeGroupCallbackFunction = function(response) {
 999                         $scope.callbackResults = "";
1000                         var color = "none";
1001                         $scope.callbackStyle = {
1002                                         "background-color" : color
1003                         };
1004
1005                         /*
1006                          * This 1/2 delay was only added to visually highlight the status
1007                          * change. Probably not needed in the real application code.
1008                          */
1009                         $timeout(function() {
1010                                 $scope.callbackResults = UtilityService.getCurrentTime()
1011                                 + " isSuccessful: " + response.isSuccessful;
1012                                 if (response.isSuccessful) {
1013                                         color = "#8F8";
1014                                         $scope.reloadRoute();
1015                                 } else {
1016                                         color = "#F88";
1017                                 }
1018                                 $scope.callbackStyle = {
1019                                                 "background-color" : color
1020                                 };
1021                         }, 500);
1022
1023
1024
1025                 };
1026
1027         });
1028 })();