2 * ============LICENSE_START=======================================================
\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
11 * http://www.apache.org/licenses/LICENSE-2.0
\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
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
28 appDS2.requires.push('ui.tree');
\r
30 appDS2.controller("InstantiationController", function ($scope, $route, $location, $timeout, COMPONENT, VIDCONFIGURATION, FIELD, DataService, PropertyService, UtilityService, VnfService, $http, vidService, AaiService,PnfService, $q) {
\r
32 $scope.popup = new Object();
\r
33 $scope.defaultBaseUrl = "";
\r
34 $scope.responseTimeoutMsec = 60000;
\r
35 $scope.properties = UtilityService.getProperties();
\r
36 $scope.resumeStatus = COMPONENT.RESUME_STATUS;
\r
37 //isPermitted - returned as string from url and converted into boolean
\r
38 $scope.isPermitted = $location.search().isPermitted == "true";
\r
39 $scope.STATUS_CONSTANTS = FIELD.STATUS;
\r
40 $scope.pnfs = [];// PNF data init;
\r
42 $scope.init = function() {
\r
44 * These 2 statements should be included in non-test code.
\r
46 // takes a default value, retrieves the prop value from the file system and sets it
\r
47 var msecs = PropertyService.retrieveMsoMaxPollingIntervalMsec();
\r
48 PropertyService.setMsoMaxPollingIntervalMsec(msecs);
\r
50 // takes a default value, retrieves the prop value from the file system and sets it
\r
51 var polls = PropertyService.retrieveMsoMaxPolls();
\r
52 PropertyService.setMsoMaxPolls(polls);
\r
54 PropertyService.setServerResponseTimeoutMsec(30000);
\r
57 * Common parameters that shows an example of how the view edit screen
\r
58 * is expected to pass some common service instance values to the
\r
62 // DataService.setSubscriberName("Mobility");
\r
63 // DataService.setGlobalCustomerId("CUSTID12345")
\r
64 // DataService.setServiceType("Mobility Type 1");
\r
65 // DataService.setServiceInstanceName("Example Service Instance Name");
\r
66 // DataService.setServiceName("Mobility Service 1");
\r
67 // DataService.setServiceInstanceId("mmsc-test-service-instance");
\r
68 // DataService.setServiceUuid("XXXX-YYYY-ZZZZ");
\r
69 // DataService.setUserServiceInstanceName("USER_SERVICE_INSTANCE_NAME");
\r
73 //PropertyService.setMsoBaseUrl("testmso");
\r
75 $scope.convertModel = function(asdcModel) {
\r
76 if (!asdcModel) return undefined;
\r
77 var convertedAsdcModel = UtilityService.convertModel(asdcModel);
\r
78 return convertedAsdcModel;
\r
82 "model": vidService.getModel(),
\r
83 "convertedModel": $scope.convertModel(vidService.getModel()),
\r
84 "instance": vidService.getInstance()
\r
90 function preparePnfs(){
\r
91 var serviceInstance = {
\r
92 globalCustomerId: $location.search().subscriberId,
\r
93 serviceType: $location.search().serviceType,
\r
94 serviceInstanceId: $location.search().serviceInstanceId
\r
97 _setPnf(serviceInstance).then(function(data){
\r
103 $scope.returnVfModules = function (vnfInstance) {
\r
105 var svcModel = $scope.service.convertedModel;
\r
106 //var vnfModelInvariantUuid = vnfInstance[FIELD.ID.MODEL_INVAR_ID];
\r
107 var vnfModelVersionId = vnfInstance[FIELD.ID.MODEL_VERSION_ID]; // model uuid
\r
108 var vnfModelCustomizationUuid = vnfInstance[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
110 var vnfModel = null;
\r
112 if ( (!($scope.isObjectEmpty(svcModel))) && ( !($scope.isObjectEmpty(svcModel.vnfs) ) ) ) {
\r
113 if ( (svcModel.isNewFlow) && (vnfModelCustomizationUuid != null ) ) {
\r
114 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
115 if ( !($scope.isObjectEmpty(vnfModel.vfModules) ) ) {
\r
116 //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.vfModules, null, 4));
\r
117 return (vnfModel.vfModules);
\r
122 if ( vnfModelVersionId != null ) {
\r
123 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
124 if ( !($scope.isObjectEmpty(vnfModel.vfModules) ) ) {
\r
125 //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.vfModules, null, 4));
\r
126 return (vnfModel.vfModules);
\r
134 $scope.hasVfModules = function (vnfInstance) {
\r
135 if ($scope.returnVfModules(vnfInstance) != null ){
\r
140 $scope.returnVolumeGroups = function (vnfInstance) {
\r
142 var svcModel = $scope.service.convertedModel;
\r
144 //var vnfModelInvariantUuid = vnfInstance[FIELD.ID.MODEL_INVAR_ID];
\r
145 var vnfModelVersionId = vnfInstance[FIELD.ID.MODEL_VERSION_ID];
\r
146 var vnfModelCustomizationUuid = vnfInstance[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
148 var vnfModel = null;
\r
150 if ( (!($scope.isObjectEmpty(svcModel))) && ( !($scope.isObjectEmpty(svcModel.vnfs) ) ) ) {
\r
151 if ( (svcModel.isNewFlow) && (vnfModelCustomizationUuid != null ) ) {
\r
152 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
153 if ( !($scope.isObjectEmpty(vnfModel.volumeGroups) ) ) {
\r
154 //console.log ("vnfModel.volumeGroups: "); console.log (JSON.stringify(vnfModel.volumeGroups, null, 4));
\r
155 return (vnfModel.volumeGroups);
\r
160 if ( vnfModelVersionId != null ) {
\r
161 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
162 if ( !($scope.isObjectEmpty(vnfModel.volumeGroups) ) ) {
\r
163 //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.volumeGroups, null, 4));
\r
164 return (vnfModel.volumeGroups);
\r
172 $scope.hasVolumeGroups = function (vnfInstance) {
\r
173 if ($scope.returnVolumeGroups(vnfInstance) != null ){
\r
178 $scope.deleteNetwork = function(serviceObject, network) {
\r
180 console.log("Removing Network " + network.name);
\r
182 //Send delete network request to MSO
\r
184 //var networks = this.service.instance.networks;
\r
186 //networks.splice(networks.indexOf(network), 1);
\r
188 //Retrieve updated data from A&AI
\r
189 var serviceInstance = serviceObject.object;
\r
190 var svcModel = $scope.service.convertedModel;
\r
192 DataService.setInventoryItem(network.object);
\r
193 // set model default and override later if found
\r
194 DataService.setModelInfo(COMPONENT.NETWORK, {});
\r
196 if ( network.object != null ) {
\r
198 //var netModelInvariantUuid = network.object[FIELD.ID.MODEL_INVAR_ID];
\r
199 var netModelVersionId = network.object[FIELD.ID.MODEL_VERSION_ID]; // model uuid
\r
200 var netModelCustomizationUuid = network.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
202 if ( (!($scope.isObjectEmpty(svcModel))) && ( !($scope.isObjectEmpty(svcModel.networks) ) ) ) {
\r
203 if ( (svcModel.isNewFlow) && (UtilityService.hasContents(netModelCustomizationUuid) ) ) {
\r
204 netModel = svcModel.networks[netModelCustomizationUuid];
\r
208 if ( UtilityService.hasContents(netModelVersionId) ) {
\r
209 netModel = svcModel.networks[netModelVersionId];
\r
215 if (!($scope.isObjectEmpty(netModel) ) ) {
\r
216 DataService.setModelInfo(COMPONENT.NETWORK, {
\r
217 "modelInvariantId": netModel.invariantUuid,
\r
218 "modelVersion": netModel.version,
\r
219 "modelNameVersionId": netModel.uuid,
\r
220 "modelCustomizationName": netModel.modelCustomizationName,
\r
221 "customizationUuid": netModel.customizationUuid,
\r
222 "modelName": netModel.name,
\r
227 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
228 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
229 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
231 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
232 DataService.setServiceInstanceName($scope.service.instance.name);
\r
233 DataService.setServiceName($scope.service.model.service.name);
\r
234 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
235 DataService.setNetworkInstanceId(network.object[FIELD.ID.NETWORK_ID]);
\r
237 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
238 componentId : COMPONENT.NETWORK,
\r
239 callbackFunction : deleteOrResumeCallback,
\r
240 dialogMethod: COMPONENT.DELETE
\r
244 $scope.deleteService = function(serviceObject) {
\r
246 var serviceInstance = serviceObject.object;
\r
248 console.log("Removing Service " + $scope.service.instance.name);
\r
250 if ( $scope.isMacro() ) {
\r
251 DataService.setALaCarte (false);
\r
254 DataService.setALaCarte (true);
\r
256 DataService.setMacro($scope.isMacro());
\r
257 DataService.setInventoryItem(serviceInstance);
\r
258 setCurrentServiceModelInfoFromScope();
\r
261 DataService.setSubscriberName(serviceObject[FIELD.ID.SUBSCRIBER_NAME]);
\r
262 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
263 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
265 DataService.setGlobalCustomerId(serviceObject[COMPONENT.GLOBAL_CUSTOMER_ID]);
\r
266 DataService.setServiceInstanceName($scope.service.instance.name);
\r
268 DataService.setServiceName($scope.service.model.service.name);
\r
270 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
272 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
273 componentId : COMPONENT.SERVICE,
\r
274 callbackFunction : deleteServiceInstanceCallbackFunction,
\r
275 dialogMethod: COMPONENT.DELETE
\r
280 function populate_popup_vfModule(serviceObject, vfModule, vnf){
\r
281 var serviceInstance = serviceObject.object;
\r
283 DataService.setInventoryItem(vfModule.object);
\r
285 var svcModel = $scope.service.convertedModel;
\r
287 //var vnfModelInvariantUuid = vnf.object[FIELD.ID.MODEL_INVAR_ID];
\r
288 var vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
289 var vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];;
\r
290 var vfModuleInstanceID = vfModule.object[FIELD.ID.VF_MODULE_ID];
\r
291 if (vfModuleInstanceID == null) {
\r
292 vfModuleInstanceID = "";
\r
295 var vnfModel = null;
\r
296 var vfModuleModel = null;
\r
298 DataService.setModelInfo(COMPONENT.VF_MODULE, {
\r
299 "modelInvariantId": "",
\r
300 "modelVersion": "",
\r
301 "modelNameVersionId": "",
\r
302 "modelCustomizationName": "",
\r
303 "customizationUuid": "",
\r
308 if ( (!($scope.isObjectEmpty(svcModel))) && ( !($scope.isObjectEmpty(svcModel.vnfs) ) ) ) {
\r
309 if ( (svcModel.isNewFlow) && (vnfModelCustomizationUuid != null ) ) {
\r
310 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
312 var vfModuleCustomizationUuid = vfModule.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
313 if ( !($scope.isObjectEmpty(vnfModel.vfModules) ) && UtilityService.hasContents(vfModuleCustomizationUuid) ) {
\r
315 vfModuleModel = vnfModel.vfModules[vfModuleCustomizationUuid];
\r
321 if (vnfModelVersionId != null ) {
\r
322 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
324 //var vfModuleInvariantUuid = vfModule.object[FIELD.ID.MODEL_INVAR_ID];
\r
325 var vfModuleModelVersionId = vfModule.object[FIELD.ID.MODEL_VERSION_ID];
\r
326 if ( (!($scope.isObjectEmpty(vnfModel))) && (!($scope.isObjectEmpty(vnfModel.vfModules))) &&
\r
327 UtilityService.hasContents(vfModuleModelVersionId) ) {
\r
328 vfModuleModel = vnfModel.vfModules[vfModuleModelVersionId];
\r
331 if ( !($scope.isObjectEmpty(vfModuleModel)) ) {
\r
332 DataService.setModelInfo(COMPONENT.VF_MODULE, {
\r
333 "modelInvariantId": vfModuleModel.invariantUuid,
\r
334 "modelVersion": vfModuleModel.version,
\r
335 "modelNameVersionId": vfModuleModel.uuid,
\r
336 "modelCustomizationName": vfModuleModel.modelCustomizationName,
\r
337 "customizationUuid": vfModuleModel.customizationUuid,
\r
338 "modelName": vfModuleModel.name,
\r
344 DataService.setVnfInstanceId(vnf.object[FIELD.ID.VNF_ID]);
\r
345 DataService.setVfModuleInstanceId(vfModuleInstanceID);
\r
347 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
348 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
349 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
351 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
352 DataService.setServiceInstanceName($scope.service.instance.name);
\r
354 DataService.setServiceName($scope.service.model.service.name);
\r
356 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
359 $scope.deleteVfModule = function(serviceObject, vfModule, vnf) {
\r
361 console.log("Removing VF-Module " + vfModule.name);
\r
363 populate_popup_vfModule(serviceObject, vfModule, vnf);
\r
365 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
366 componentId : COMPONENT.VF_MODULE,
\r
367 callbackFunction : deleteOrResumeCallback,
\r
368 dialogMethod: COMPONENT.DELETE
\r
375 function setCurrentServiceModelInfoFromScope(){
\r
376 DataService.setModelInfo(COMPONENT.SERVICE, {
\r
377 "modelInvariantId": $scope.service.model.service.invariantUuid,
\r
378 "modelVersion": $scope.service.model.service.version,
\r
379 "modelNameVersionId": $scope.service.model.service.uuid,
\r
380 "modelName": $scope.service.model.service.name,
\r
385 function setCurrentVNFModelInfo(vnf){
\r
386 var svcModel = $scope.service.convertedModel;
\r
388 var vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
389 var vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
390 if ( (!($scope.isObjectEmpty(svcModel))) && ( !($scope.isObjectEmpty(svcModel.vnfs) ) ) ) {
\r
391 if ( (svcModel.isNewFlow) && (vnfModelCustomizationUuid != null ) ) {
\r
392 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
395 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
397 if ( !($scope.isObjectEmpty(vnfModel) ) ) {
\r
399 DataService.setModelInfo(COMPONENT.VNF, {
\r
400 "modelInvariantId": vnfModel.invariantUuid,
\r
401 "modelVersion": vnfModel.version,
\r
402 "modelNameVersionId": vnfModel.uuid,
\r
403 "modelCustomizationName": vnfModel.modelCustomizationName,
\r
404 "customizationUuid": vnfModel.customizationUuid,
\r
405 "modelName": vnfModel.name,
\r
415 $scope.deleteVnf = function(serviceObject, vnf) {
\r
416 console.log("Removing VNF " + vnf.name);
\r
418 var serviceInstance = serviceObject.object;
\r
419 var svcModel = $scope.service.convertedModel;
\r
420 DataService.setInventoryItem(vnf.object);
\r
422 /*var vnftype = vnf.object['vnf-type'];
\r
423 if (vnftype == null)
\r
427 var n = vnftype.search("/");
\r
429 vnftype = vnftype.substring(n+1);
\r
432 var svcModel = $scope.service.convertedModel;
\r
433 var vnfModelInvariantUuid = null;
\r
434 var vnfModelVersion = null;
\r
435 var vnfModelCustomizationUuid = null;
\r
436 var vnfModel = null;
\r
437 var vnfModelVersionId = null;
\r
439 vnfModelInvariantUuid = vnf.object[FIELD.ID.MODEL_INVAR_ID];
\r
440 vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
441 vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
443 DataService.setModelInfo(COMPONENT.VNF, {
\r
444 "modelInvariantId": vnfModelInvariantUuid,
\r
445 "modelVersion": "",
\r
446 "modelNameVersionId": vnfModelVersionId,
\r
447 "modelCustomizationName": "",
\r
448 "customizationUuid": vnfModelCustomizationUuid,
\r
453 if ( (!($scope.isObjectEmpty(svcModel))) && ( !($scope.isObjectEmpty(svcModel.vnfs) ) ) ) {
\r
454 if ( (svcModel.isNewFlow) && (vnfModelCustomizationUuid != null ) ) {
\r
455 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
458 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
460 //console.log ( "vnf models: "); console.log ( JSON.stringify ($scope.service.convertedModel.vnfs, null, 4) );
\r
461 if ( !($scope.isObjectEmpty(vnfModel) ) ) {
\r
463 DataService.setModelInfo(COMPONENT.VNF, {
\r
464 "modelInvariantId": vnfModel.invariantUuid,
\r
465 "modelVersion": vnfModel.version,
\r
466 "modelNameVersionId": vnfModel.uuid,
\r
467 "modelCustomizationName": vnfModel.modelCustomizationName,
\r
468 "customizationUuid": vnfModel.customizationUuid,
\r
469 "modelName": vnfModel.name,
\r
475 DataService.setVnfInstanceId(vnf.object[FIELD.ID.VNF_ID]);
\r
477 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
478 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
479 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
481 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
482 DataService.setServiceInstanceName($scope.service.instance.name);
\r
484 DataService.setServiceName($scope.service.model.service.name);
\r
486 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
488 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
489 componentId : COMPONENT.VNF,
\r
490 callbackFunction : deleteOrResumeCallback,
\r
491 dialogMethod: COMPONENT.DELETE
\r
498 $scope.deleteVolumeGroup = function(serviceObject, vnf, vfModule, volumeGroup) {
\r
500 console.log("Removing Volume Group " + volumeGroup.name);
\r
501 var haveModel = false;
\r
502 var svcModel = $scope.service.convertedModel;
\r
504 var vnfModelInvariantUuid = null;
\r
505 var vnfModelVersion = null;
\r
506 var vnfModelCustomizationUuid = null;
\r
507 var vnfModel = null;
\r
508 var vnfModelVersionId = null;
\r
510 vnfModelInvariantUuid = vnf.object[FIELD.ID.MODEL_INVAR_ID];
\r
511 vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
512 vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
514 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
\r
515 "modelInvariantId": "",
\r
516 "modelVersion": "",
\r
517 "modelNameVersionId": "",
\r
518 "modelCustomizationName": "",
\r
519 "customizationUuid": "",
\r
524 if ( (!($scope.isObjectEmpty(svcModel))) && ( !($scope.isObjectEmpty(svcModel.vnfs) ) ) ) {
\r
525 if ( (svcModel.isNewFlow) && (vnfModelCustomizationUuid != null ) ) {
\r
526 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
529 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
534 // volume groups don't have model-invariant-id/version in a&ai.
\r
535 // Their model-invariant-id/version is the one for the associated vfModule
\r
537 var vfModuleInvariantUuid = vfModule.object[FIELD.ID.MODEL_INVAR_ID];
\r
538 var vfModuleModelVersionId = vfModule.object[FIELD.ID.MODEL_VERSION_ID];
\r
539 var vfModuleCustomizationUuid = vfModule.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
540 var volGroupModel = null;
\r
542 if ( !($scope.isObjectEmpty(vnfModel.volumeGroups) ) ) {
\r
543 if ( ( !($scope.isObjectEmpty(vnfModel) ) ) && ( !($scope.isObjectEmpty(vnfModel.volumeGroups) ) ) ) {
\r
544 if ( (svcModel.isNewFlow) && (UtilityService.hasContents(vfModuleCustomizationUuid) ) ){
\r
545 volGroupModel = vnfModel.volumeGroups[vfModuleCustomizationUuid];
\r
548 volGroupModel = vnfModel.volumeGroups[vfModuleModelVersionId];
\r
550 if ( !($scope.isObjectEmpty(volGroupModel) ) ) {
\r
551 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
\r
552 "modelInvariantId": volGroupModel.invariantUuid,
\r
553 "modelVersion": volGroupModel.version,
\r
554 "modelNameVersionId": volGroupModel.uuid,
\r
555 "modelCustomizationName": volGroupModel.modelCustomizationName,
\r
556 "customizationUuid": volGroupModel.customizationUuid,
\r
557 "modelName": volGroupModel.name,
\r
565 var serviceInstance = serviceObject.object;
\r
567 DataService.setInventoryItem(volumeGroup.object);
\r
569 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
570 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
571 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
573 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
574 DataService.setServiceInstanceName($scope.service.instance.name);
\r
576 DataService.setServiceName($scope.service.model.service.name);
\r
578 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
579 DataService.setVnfInstanceId(vnf.nodeId);
\r
580 DataService.setVolumeGroupInstanceId(volumeGroup.nodeId);
\r
582 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
583 componentId : COMPONENT.VOLUME_GROUP,
\r
584 dialogMethod: COMPONENT.DELETE
\r
588 $scope.deleteVnfVolumeGroup = function(serviceObject, vnf, volumeGroup) {
\r
590 console.log("Removing Volume Group " + volumeGroup.name);
\r
591 var serviceInstance = serviceObject.object;
\r
593 DataService.setInventoryItem(volumeGroup.object);
\r
595 var svcModel = $scope.service.convertedModel;
\r
597 var vnfModelInvariantUuid = vnf.object[FIELD.ID.MODEL_INVAR_ID];
\r
598 var vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
599 var vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
601 var volGroupModelInvariantUuid = volumeGroup.object[FIELD.ID.MODEL_INVAR_ID];
\r
602 var volGroupModelVersionId = volumeGroup.object[FIELD.ID.MODEL_VERSION_ID];
\r
603 var volGroupModelCustomizationUuid = volumeGroup.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
605 var vnfModel = null;
\r
606 var volGroupModel = null;
\r
608 // send an empty model by default since model is not required for deletes
\r
609 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {});
\r
611 if ( svcModel.isNewFlow ) {
\r
612 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
613 if ( UtilityService.hasContents (volGroupModelCustomizationUuid) ) {
\r
614 volGroupModel = vnfModel.volumeGroups[volGroupModelCustomizationUuid];
\r
619 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
620 if ( UtilityService.hasContents (volGroupModelVersionId) ) {
\r
621 volGroupModel = vnfModel.volumeGroups[volGroupModelVersionId];
\r
624 if ( !($scope.isObjectEmpty(volGroupModel) ) ) {
\r
625 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
\r
626 "modelInvariantId": volGroupModel.invariantUuid,
\r
627 "modelVersion": volGroupModel.version,
\r
628 "modelNameVersionId": volGroupModel.uuid,
\r
629 "modelName": volGroupModel.name,
\r
630 "modelCustomizationName": volGroupModel.modelCustomizationName,
\r
631 "customizationUuid": volGroupModel.customizationUuid,
\r
636 DataService.setVnfInstanceId(vnf.object[FIELD.ID.VNF_ID]);
\r
638 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
639 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
640 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
642 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
643 DataService.setServiceInstanceName($scope.service.instance.name);
\r
645 DataService.setServiceName($scope.service.model.service.name);
\r
647 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
648 DataService.setVnfInstanceId(vnf.nodeId);
\r
649 DataService.setVolumeGroupInstanceId(volumeGroup.nodeId);
\r
651 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
652 componentId : COMPONENT.VOLUME_GROUP,
\r
653 callbackFunction : deleteOrResumeCallback,
\r
654 dialogMethod: COMPONENT.DELETE
\r
658 $scope.describeNetwork = function(serviceObject, networkObject) {
\r
659 var serviceInstance = serviceObject.object;
\r
660 var network = networkObject.object;
\r
661 //console.log ("networkObject="); console.log (JSON.stringify(networkObject, null, 4));
\r
663 DataService.setResCustomizationUuid(" ");
\r
665 var svcModel = $scope.service.convertedModel;
\r
666 var netModel = null;
\r
668 if ( !($scope.isObjectEmpty(network) ) ) {
\r
670 var netModelInvariantUuid = network[FIELD.ID.MODEL_INVAR_ID];
\r
671 var netModelVersionId = network[FIELD.ID.MODEL_VERSION_ID];
\r
672 var netModelCustomizationUuid = network[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
674 if ( UtilityService.hasContents (netModelCustomizationUuid) ) {
\r
675 // set it to what came from a&ai
\r
676 DataService.setResCustomizationUuid(netModelCustomizationUuid);
\r
679 if ( (!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.networks))) ) {
\r
680 if ( svcModel.isNewFlow ) {
\r
681 netModel = svcModel.networks[netModelCustomizationUuid];
\r
684 netModel = svcModel.networks[netModelVersionId];
\r
687 * The details pop-up should use a&ai info
\r
688 * if ( !($scope.isObjectEmpty(netModel) ) ) {
\r
689 if (UtilityService.hasContents(netModel.customizationUuid)) {
\r
690 DataService.setResCustomizationUuid(netModel.customizationUuid);
\r
696 DataService.setNetworkInstanceId(network[FIELD.ID.NETWORK_ID]);
\r
697 DataService.setInventoryItem(networkObject);
\r
698 DataService.setSubscriberName(serviceObject.subscriberName);
\r
699 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
700 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
702 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
703 componentId : COMPONENT.NETWORK
\r
707 // for service instance id - no need for this!
\r
708 $scope.describeService = function(serviceObject) {
\r
709 var serviceInstance = serviceObject.object;
\r
711 DataService.setInventoryItem(serviceInstance);
\r
712 //DataService.setModelInfo(serviceInstance['service-instance-id'], serviceInstance);
\r
714 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
715 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
716 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
718 //Display popup with additional service information
\r
719 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
720 componentId : COMPONENT.SERVICE
\r
725 $scope.describeVfModule = function(serviceObject, vfModuleObject, vnf) {
\r
726 var serviceInstance = serviceObject.object;
\r
727 var vfModule = vfModuleObject.object;
\r
729 /*var vfModuleInvariantUuid = vfModule[FIELD.ID.MODEL_INVAR_ID];
\r
730 var vfModuleModelVersionId = vfModule[FIELD.ID.MODEL_VERSION_ID];*/
\r
731 var vfModuleCustomizationUuid = vfModule[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
733 DataService.setCustomizationUuid(" ");
\r
734 if ( UtilityService.hasContents (vfModuleCustomizationUuid) ) {
\r
735 DataService.setCustomizationUuid(vfModuleCustomizationUuid);
\r
738 //Display popup with additional VF-Module information
\r
739 DataService.setVfModuleInstanceId(vfModule[FIELD.ID.VF_MODULE_ID]);
\r
740 DataService.setInventoryItem(vfModule)
\r
742 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
743 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
744 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
746 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
747 componentId : COMPONENT.VF_MODULE
\r
751 $scope.getStatusOfVnf = function(serviceObject, vnfObject) {
\r
752 var serviceInstance = serviceObject.object;
\r
753 var vnf = vnfObject.object;
\r
755 DataService.setVnfInstanceId(vnf[FIELD.ID.VNF_ID]);
\r
756 DataService.setInventoryItem(vnf);
\r
758 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
759 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
760 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
761 DataService.setServiceInstanceName(serviceInstance[FIELD.ID.SERVICE_INSTANCE_NAME]);
\r
763 $scope.$broadcast(COMPONENT.COMPONENT_STATUS, {
\r
764 componentId : COMPONENT.VNF,
\r
765 callbackFunction : updateProvStatusVnfCallbackFunction
\r
769 $scope.describeVnf = function(serviceObject, vnfObject) {
\r
770 var serviceInstance = serviceObject.object;
\r
771 var vnf = vnfObject.object;
\r
772 DataService.setResCustomizationUuid(" ");
\r
774 //var vnfInvariantUuid = vnf[FIELD.ID.MODEL_INVAR_ID];
\r
775 //var vnfVersionId = vnf[FIELD.ID.MODEL_VERSION_ID];
\r
776 var vnfCustomizationUuid = vnf[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
778 if ( UtilityService.hasContents (vnfCustomizationUuid) ) {
\r
779 DataService.setResCustomizationUuid(vnfCustomizationUuid);
\r
781 //Display popup with additional VNF information
\r
782 DataService.setVnfInstanceId(vnf[FIELD.ID.VNF_ID]);
\r
783 DataService.setInventoryItem(vnf);
\r
785 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
786 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
787 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
789 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
790 componentId : COMPONENT.VNF
\r
794 $scope.describeVolumeGroup = function(serviceObject, vnf, volumeGroupObject) {
\r
796 var serviceInstance = serviceObject.object;
\r
797 var volumeGroup = volumeGroupObject.object;
\r
799 //var volGroupInvariantUuid = volumeGroup[FIELD.ID.MODEL_INVAR_ID];
\r
800 //var volGroupVersionId = volumeGroup[FIELD.ID.MODEL_VERSION_ID];
\r
801 var volGroupCustomizationUuid = volumeGroup[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
803 DataService.setCustomizationUuid(" ");
\r
804 if ( UtilityService.hasContents(volGroupCustomizationUuid) ) {
\r
805 DataService.setCustomizationUuid(volGroupCustomizationUuid);
\r
807 DataService.setVolumeGroupInstanceId(volumeGroup[FIELD.ID.VOLUME_GROUP_ID]);
\r
808 DataService.setInventoryItem(volumeGroup);
\r
810 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
811 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
812 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
815 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
816 componentId : COMPONENT.VOLUME_GROUP
\r
820 $scope.addNetworkInstance = function(netModel, existingVnfs) {
\r
822 // For networks we assume that we always follow the new flow
\r
823 console.log("Adding network to service instance" + this.service.instance.name);
\r
824 if ( VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED && (UtilityService.hasContents(existingVnfs)) && (existingVnfs.length > 0) ) {
\r
825 var msg = VnfService.isVnfListStatusValid (existingVnfs);
\r
832 DataService.setSubscriberName($scope.service.instance.subscriberName);
\r
833 DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
\r
834 DataService.setServiceType($scope.service.instance.serviceType);
\r
835 DataService.setServiceInstanceName($scope.service.instance.name);
\r
836 DataService.setServiceInstanceId($scope.service.instance.id);
\r
837 DataService.setServiceName($scope.service.model.service.name);
\r
839 DataService.setModelInfo(COMPONENT.NETWORK, {
\r
840 "modelType": "network",
\r
841 "modelInvariantId": netModel.invariantUuid,
\r
842 "modelVersion": netModel.version,
\r
843 "modelNameVersionId": netModel.uuid,
\r
844 "modelName": netModel.name,
\r
845 "modelCustomizationName": netModel.modelCustomizationName,
\r
846 "customizationUuid": netModel.customizationUuid,
\r
848 "displayInputs": netModel.displayInputs
\r
850 setCurrentServiceModelInfoFromScope();
\r
853 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {
\r
854 componentId : COMPONENT.NETWORK,
\r
855 callbackFunction : createVnfCallbackFunction
\r
859 $scope.addVnfInstance = function(vnf, existingVnfs) {
\r
861 if ( VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED && (UtilityService.hasContents(existingVnfs)) && (existingVnfs.length > 0) ) {
\r
862 var msg = VnfService.isVnfListStatusValid (existingVnfs);
\r
868 DataService.setSubscriberName($scope.service.instance.subscriberName);
\r
869 DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
\r
870 DataService.setServiceType($scope.service.instance.serviceType);
\r
871 DataService.setServiceInstanceName($scope.service.instance.name);
\r
872 DataService.setServiceInstanceId($scope.service.instance.id);
\r
873 DataService.setServiceName($scope.service.model.service.name);
\r
875 console.log ( "existingVnfs: " );
\r
876 console.log (JSON.stringify ( existingVnfs, null, 4));
\r
877 console.log ( "existingVnfs: " ); console.log (JSON.stringify ( existingVnfs, null, 4));
\r
880 var vnf_function = "";
\r
883 if (UtilityService.hasContents (vnf.nfType) ) {
\r
884 vnf_type = vnf.nfType;
\r
886 if (UtilityService.hasContents (vnf.nfRole) ) {
\r
887 vnf_role = vnf.nfRole;
\r
889 if (UtilityService.hasContents (vnf.nfFunction) ) {
\r
890 vnf_function = vnf.nfFunction;
\r
892 if (UtilityService.hasContents (vnf.nfCode) ) {
\r
893 vnf_code = vnf.nfCode;
\r
895 DataService.setModelInfo(COMPONENT.VNF, {
\r
896 "modelType": vnf.isPnf ? "pnf" : "vnf",
\r
897 "modelInvariantId": vnf.invariantUuid,
\r
898 "modelVersion": vnf.version,
\r
899 "modelNameVersionId": vnf.uuid,
\r
900 "modelName": vnf.name,
\r
901 "modelCustomizationName": vnf.modelCustomizationName,
\r
902 "customizationUuid": vnf.customizationUuid,
\r
904 "displayInputs": vnf.displayInputs,
\r
905 "vnfType": vnf_type,
\r
906 "vnfRole": vnf_role,
\r
907 "vnfFunction": vnf_function,
\r
908 "vnfCode": vnf_code,
\r
909 "properties": vnf.properties
\r
912 DataService.setModelInstanceName($scope.service.model.service.name);
\r
913 setCurrentServiceModelInfoFromScope();
\r
915 if (vnf.isConfig) {
\r
916 DataService.setServiceProxies($scope.service.model.serviceProxies);
\r
917 DataService.setSourceServiceProxies(vnf.sourceNodes);
\r
918 DataService.setCollectorServiceProxies(vnf.collectorNodes);
\r
919 DataService.setConfigurationByPolicy(vnf.isConfigurationByPolicy);
\r
920 $location.path("/addNetworkNode");
\r
921 } else if(vnf.isPnf){
\r
922 $location.path("/pnfSearchAssociation");
\r
924 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {
\r
925 componentId: COMPONENT.VNF,
\r
926 callbackFunction: createVnfCallbackFunction
\r
931 $scope.addVfModuleInstance = function(vnfInstance, vfModuleModel) {
\r
933 if ( VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED ) {
\r
934 var msg = VnfService.isVnfStatusValid (vnfInstance);
\r
941 var svcModel = $scope.service.convertedModel;
\r
942 DataService.setSubscriberName($scope.service.instance.subscriberName);
\r
943 DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
\r
944 DataService.setServiceType($scope.service.instance.serviceType);
\r
945 DataService.setServiceInstanceName($scope.service.instance.name);
\r
946 DataService.setServiceInstanceId($scope.service.instance.id);
\r
947 DataService.setServiceName($scope.service.model.service.name);
\r
949 var vnfModelInvariantUuid = vnfInstance.object[FIELD.ID.MODEL_INVAR_ID];
\r
950 var vnfModelVersionId = vnfInstance.object[FIELD.ID.MODEL_VERSION_ID];
\r
951 var vnfModelCustomizationUuid = vnfInstance.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
952 var vnfModel = null;
\r
953 if ( svcModel.isNewFlow ) {
\r
954 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
957 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
960 var availableVolumeGroupList = [];
\r
961 angular.forEach(vnfInstance[FIELD.ID.AVAILABLEVOLUMEGROUPS], function(volumeGroupInstance, key) {
\r
962 availableVolumeGroupList.push({"instance": volumeGroupInstance});
\r
965 DataService.setAvailableVolumeGroupList(availableVolumeGroupList);
\r
966 setCurrentServiceModelInfoFromScope();
\r
968 DataService.setVnfInstanceId(vnfInstance.object[FIELD.ID.VNF_ID]);
\r
970 DataService.setModelInfo(COMPONENT.VNF, {
\r
971 "modelInvariantId": vnfModel.invariantUuid,
\r
972 "modelVersion": vnfModel.version,
\r
973 "modelNameVersionId": vnfModel.uuid,
\r
974 "modelName": vnfModel.name,
\r
975 "modelCustomizationName": vnfModel.modelCustomizationName,
\r
976 "customizationUuid": vnfModel.customizationUuid,
\r
980 DataService.setModelInfo(COMPONENT.VF_MODULE, {
\r
981 "modelInvariantId": vfModuleModel.invariantUuid,
\r
982 "modelVersion": vfModuleModel.version,
\r
983 "modelNameVersionId": vfModuleModel.uuid,
\r
984 "customizationUuid": vfModuleModel.customizationUuid,
\r
985 "modelCustomizationName": vfModuleModel.modelCustomizationName,
\r
986 "modelName": vfModuleModel.name,
\r
990 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {
\r
991 componentId : COMPONENT.VF_MODULE,
\r
992 callbackFunction : createVfModuleCallbackFunction
\r
997 $scope.addVolumeGroupInstance = function(vnfInstance, volumeGroupModel) {
\r
998 if ( VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED ) {
\r
999 var msg = VnfService.isVnfStatusValid (vnfInstance);
\r
1000 if ( msg != "" ) {
\r
1005 var svcModel = $scope.service.convertedModel;
\r
1006 DataService.setSubscriberName($scope.service.instance.subscriberName);
\r
1007 DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
\r
1008 DataService.setServiceType($scope.service.instance.serviceType);
\r
1009 DataService.setServiceInstanceName($scope.service.instance.name);
\r
1010 DataService.setServiceInstanceId($scope.service.instance.id);
\r
1011 DataService.setServiceName($scope.service.model.service.name);
\r
1012 setCurrentServiceModelInfoFromScope();
\r
1014 DataService.setModelInfo(COMPONENT.SERVICE, {
\r
1015 "modelInvariantId": $scope.service.model.service.invariantUuid,
\r
1016 "modelVersion": $scope.service.model.service.version,
\r
1017 "modelNameVersionId": $scope.service.model.service.uuid,
\r
1018 "modelName": $scope.service.model.service.name,
\r
1022 DataService.setVnfInstanceId(vnfInstance.object[FIELD.ID.VNF_ID]);
\r
1024 var vnfModelInvariantUuid = vnfInstance.object[FIELD.ID.MODEL_INVAR_ID];
\r
1025 var vnfModelVersionId = vnfInstance.object[FIELD.ID.MODEL_VERSION_ID];
\r
1026 var vnfCustomizationUuid = vnfInstance.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
1027 var vnfModel = null;
\r
1029 if ( svcModel.isNewFlow ) {
\r
1030 vnfModel = svcModel.vnfs[vnfCustomizationUuid];
\r
1033 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
1036 DataService.setModelInfo(COMPONENT.VNF, {
\r
1037 "modelInvariantId": vnfModel.invariantUuid,
\r
1038 "modelVersion": vnfModel.version,
\r
1039 "modelNameVersionId": vnfModel.uuid,
\r
1040 "modelName": vnfModel.name,
\r
1041 "modelCustomizationName": vnfModel.modelCustomizationName,
\r
1042 "customizationUuid": vnfModel.customizationUuid,
\r
1046 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
\r
1047 "modelInvariantId": volumeGroupModel.invariantUuid,
\r
1048 "modelVersion": volumeGroupModel.version,
\r
1049 "modelNameVersionId": volumeGroupModel.uuid,
\r
1050 "modelName": volumeGroupModel.name,
\r
1051 "modelCustomizationName": volumeGroupModel.modelCustomizationName,
\r
1052 "customizationUuid": volumeGroupModel.customizationUuid,
\r
1056 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {
\r
1057 componentId : COMPONENT.VOLUME_GROUP,
\r
1058 callbackFunction : createVolumeGroupCallbackFunction
\r
1062 $scope.resume = function(serviceObject, vfModule, vnfModel) {
\r
1063 populate_popup_vfModule(serviceObject, vfModule, vnfModel);
\r
1064 setCurrentVNFModelInfo(vnfModel);
\r
1065 DataService.setVfModuleInstanceName(vfModule.object[FIELD.ID.VF_MODULE_NAME]);
\r
1066 setCurrentServiceModelInfoFromScope();
\r
1067 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
1068 componentId : COMPONENT.VF_MODULE,
\r
1069 callbackFunction : deleteOrResumeCallback,
\r
1070 dialogMethod: COMPONENT.RESUME
\r
1074 $scope.deleteConfiguration = function (serviceObject, configuration) {
\r
1075 console.log("Deleting Configuration " + configuration.name);
\r
1077 var serviceInstance = serviceObject.object;
\r
1078 var svcModel = $scope.service.convertedModel;
\r
1080 DataService.setInventoryItem(configuration.object);
\r
1081 // set model default and override later if found
\r
1082 DataService.setModelInfo(COMPONENT.CONFIGURATION, {});
\r
1084 if ( configuration.object != null ) {
\r
1086 //var netModelInvariantUuid = network.object[FIELD.ID.MODEL_INVAR_ID];
\r
1087 var configModelVersionId = configuration.object[FIELD.ID.MODEL_VERSION_ID]; // model uuid
\r
1088 var configModelCustomizationUuid = configuration.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
1090 //configurations added to vnfs list, in order to be part of the "Add VNF" drop-down list
\r
1091 if ( (!($scope.isObjectEmpty(svcModel))) && ( !($scope.isObjectEmpty(svcModel.vnfs) ) ) ) {
\r
1092 if ( (svcModel.isNewFlow) && (UtilityService.hasContents(configModelCustomizationUuid) ) ) {
\r
1093 configModel = svcModel.vnfs[configModelCustomizationUuid];
\r
1097 if ( UtilityService.hasContents(configModelVersionId) ) {
\r
1098 configModel = svcModel.vnfs[configModelVersionId];
\r
1104 if (!($scope.isObjectEmpty(configModel) ) ) {
\r
1105 DataService.setModelInfo(COMPONENT.CONFIGURATION, {
\r
1106 "modelInvariantId": configModel.invariantUuid,
\r
1107 "modelVersion": configModel.version,
\r
1108 "modelNameVersionId": configModel.uuid,
\r
1109 "modelCustomizationName": configModel.modelCustomizationName,
\r
1110 "customizationUuid": configModel.customizationUuid,
\r
1111 "modelName": configModel.name,
\r
1116 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
1117 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
1118 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
1120 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
1121 DataService.setServiceInstanceName($scope.service.instance.name);
\r
1122 DataService.setServiceName($scope.service.model.service.name);
\r
1123 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
1124 DataService.setConfigurationInstanceId(configuration.object[FIELD.ID.CONFIGURATION_ID]);
\r
1126 $scope.$broadcast(COMPONENT.DELETE_COMPONENT, {
\r
1127 componentId : COMPONENT.CONFIGURATION,
\r
1128 callbackFunction : deleteCallbackFunction
\r
1132 $scope.resetProgress = function() {
\r
1133 $scope.percentProgress = 0;
\r
1134 $scope.progressClass = FIELD.STYLE.PROGRESS_BAR_INFO;
\r
1137 $scope.setProgress = function(percentProgress) {
\r
1138 percentProgress = parseInt(percentProgress);
\r
1139 if (percentProgress >= 100) {
\r
1140 $scope.progressClass = FIELD.STYLE.PROGRESS_BAR_SUCCESS;
\r
1143 if (percentProgress < $scope.percentProgress) {
\r
1147 $scope.percentProgress = percentProgress;
\r
1148 $scope.progressWidth = {width: percentProgress + "%"};
\r
1149 if (percentProgress >= 5) {
\r
1150 $scope.progressText = percentProgress + " %";
\r
1152 // Hidden since color combination is barely visible when progress portion is narrow.
\r
1153 $scope.progressText = "";
\r
1156 $scope.isObjectEmpty = function(o) {
\r
1158 if (UtilityService.hasContents(o)){
\r
1159 var keys = Object.keys(o);
\r
1160 len = keys.length;
\r
1172 $scope.isMacro = function() {
\r
1173 if (UtilityService.arrayContains (VIDCONFIGURATION.MACRO_SERVICES, $scope.service.model.service.invariantUuid )) {
\r
1181 $scope.reloadRoute = function() {
\r
1193 * set the controller pnf param using api call
\r
1196 function _setPnf(data){ // data is the $scope.service.instance object
\r
1197 return PnfService.getPnfs(data)
\r
1199 function success(response){
\r
1200 return response.data;
\r
1201 // * can add here changes on the data that are needed to the view ( filter, ect..)
\r
1203 function error(error){
\r
1204 console.error(error);
\r
1210 Callbaks functions
\r
1213 var updateProvStatusVnfCallbackFunction = function(response) {
\r
1214 $scope.callbackResults = "";
\r
1215 var color = FIELD.ID.COLOR_NONE;
\r
1216 $scope.callbackStyle = {
\r
1217 "background-color" : color
\r
1219 $scope.reloadRoute();
\r
1221 * This 1/2 delay was only added to visually highlight the status
\r
1222 * change. Probably not needed in the real application code.
\r
1224 $timeout(function() {
\r
1225 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1226 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1227 if (response.isSuccessful) {
\r
1228 color = FIELD.ID.COLOR_8F8;
\r
1231 color = FIELD.ID.COLOR_F88;
\r
1233 $scope.callbackStyle = {
\r
1234 "background-color" : color
\r
1240 var createVnfCallbackFunction = function(response) {
\r
1241 $scope.callbackResults = "";
\r
1242 var color = FIELD.ID.COLOR_NONE;
\r
1243 $scope.callbackStyle = {
\r
1244 "background-color" : color
\r
1248 * This 1/2 delay was only added to visually highlight the status
\r
1249 * change. Probably not needed in the real application code.
\r
1251 $timeout(function() {
\r
1252 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1253 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1254 if (response.isSuccessful) {
\r
1255 color = FIELD.ID.COLOR_8F8;
\r
1256 $scope.reloadRoute();
\r
1258 color = FIELD.ID.COLOR_F88;
\r
1260 $scope.callbackStyle = {
\r
1261 "background-color" : color
\r
1269 var deleteOrResumeCallback = function(response) {
\r
1270 $scope.callbackResults = "";
\r
1271 var color = FIELD.ID.COLOR_NONE;
\r
1272 $scope.callbackStyle = {
\r
1273 "background-color" : color
\r
1277 * This 1/2 delay was only added to visually highlight the status
\r
1278 * change. Probably not needed in the real application code.
\r
1280 $timeout(function() {
\r
1281 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1282 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1283 if (response.isSuccessful) {
\r
1284 color = FIELD.ID.COLOR_8F8;
\r
1285 $scope.reloadRoute();
\r
1287 color = FIELD.ID.COLOR_F88;
\r
1289 $scope.callbackStyle = {
\r
1290 "background-color" : color
\r
1296 var createVfModuleCallbackFunction = function(response) {
\r
1297 $scope.callbackResults = "";
\r
1298 var color = FIELD.ID.COLOR_NONE;
\r
1299 $scope.callbackStyle = {
\r
1300 "background-color" : color
\r
1304 * This 1/2 delay was only added to visually highlight the status
\r
1305 * change. Probably not needed in the real application code.
\r
1307 $timeout(function() {
\r
1308 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1309 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1310 if (response.isSuccessful) {
\r
1311 color = FIELD.ID.COLOR_8F8;
\r
1312 $scope.reloadRoute();
\r
1314 color = FIELD.ID.COLOR_F88;
\r
1316 $scope.callbackStyle = {
\r
1317 "background-color" : color
\r
1323 var deleteServiceInstanceCallbackFunction = function(response) {
\r
1324 $scope.callbackResults = "";
\r
1325 var color = FIELD.ID.COLOR_NONE;
\r
1326 $scope.callbackStyle = {
\r
1327 "background-color" : color
\r
1331 * This 1/2 delay was only added to visually highlight the status
\r
1332 * change. Probably not needed in the real application code.
\r
1334 $timeout(function() {
\r
1335 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1336 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1337 if (response.isSuccessful) {
\r
1338 color = FIELD.ID.COLOR_8F8;
\r
1339 $location.path(COMPONENT.SERVICEMODELS_MODELS_SERVICES_PATH)
\r
1341 color = FIELD.ID.COLOR_F88;
\r
1343 $scope.callbackStyle = {
\r
1344 "background-color" : color
\r
1350 var createVolumeGroupCallbackFunction = function(response) {
\r
1351 $scope.callbackResults = "";
\r
1352 var color = FIELD.ID.COLOR_NONE;
\r
1353 $scope.callbackStyle = {
\r
1354 "background-color" : color
\r
1358 * This 1/2 delay was only added to visually highlight the status
\r
1359 * change. Probably not needed in the real application code.
\r
1361 $timeout(function() {
\r
1362 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1363 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1364 if (response.isSuccessful) {
\r
1365 color = FIELD.ID.COLOR_8F8;
\r
1366 $scope.reloadRoute();
\r
1368 color = FIELD.ID.COLOR_F88;
\r
1370 $scope.callbackStyle = {
\r
1371 "background-color" : color
\r