2 * ============LICENSE_START=======================================================
\r
4 * ================================================================================
\r
5 * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
\r
6 * Modifications Copyright (C) 2019 IBM.
\r
7 * ================================================================================
\r
8 * Licensed under the Apache License, Version 2.0 (the "License");
\r
9 * you may not use this file except in compliance with the License.
\r
10 * You may obtain a copy of the License at
\r
12 * http://www.apache.org/licenses/LICENSE-2.0
\r
14 * Unless required by applicable law or agreed to in writing, software
\r
15 * distributed under the License is distributed on an "AS IS" BASIS,
\r
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
\r
17 * See the License for the specific language governing permissions and
\r
18 * limitations under the License.
\r
19 * ============LICENSE_END=========================================================
\r
23 * The Instantiation (or View/Edit) Controller controls the instantiation/removal of
\r
24 * deployable objects (Services, VNFs, VF-Modules, Networks, and Volume-Groups)
\r
29 appDS2.requires.push('ui.tree');
\r
31 appDS2.controller("InstantiationController", function ($scope, $route, $location, $timeout, $uibModal, COMPONENT, VIDCONFIGURATION, FIELD, DataService, PropertyService, UtilityService, VnfService, $http, vidService, AaiService, PnfService, CrService, AsdcService, $q, featureFlags, _, CreationService, $window, DeleteResumeService) {
\r
32 $scope.popup = new Object();
\r
33 $scope.defaultBaseUrl = "";
\r
34 $scope.responseTimeoutMsec = 60000;
\r
35 $scope.properties = UtilityService.getProperties();
\r
36 $scope.resumeStatus = COMPONENT.RESUME_STATUS;
\r
37 //isPermitted - returned as string from url and converted into boolean
\r
38 $scope.isPermitted = $location.search().isPermitted == "true";
\r
39 $scope.STATUS_CONSTANTS = FIELD.STATUS;
\r
40 $scope.pnfs = [];// PNF data init;
\r
41 $scope.collectionResource = {};
\r
42 $scope.collections = [];
\r
43 $scope.networks = [];
\r
44 $scope.isCR = false;
\r
45 $scope.isVFC = false;
\r
46 $scope.init = function () {
\r
48 * These 2 statements should be included in non-test code.
\r
50 // takes a default value, retrieves the prop value from the file system and sets it
\r
51 var msecs = PropertyService.retrieveMsoMaxPollingIntervalMsec();
\r
52 PropertyService.setMsoMaxPollingIntervalMsec(msecs);
\r
54 // takes a default value, retrieves the prop value from the file system and sets it
\r
55 var polls = PropertyService.retrieveMsoMaxPolls();
\r
56 PropertyService.setMsoMaxPolls(polls);
\r
60 $scope.convertModel = function (asdcModel) {
\r
61 if (!asdcModel) return undefined;
\r
62 var convertedAsdcModel = UtilityService.convertModel(asdcModel);
\r
63 return convertedAsdcModel;
\r
66 $scope.prepareScopeWithModel = function () {
\r
68 if (!vidService.getModel()) return;
\r
71 "model": vidService.getModel(),
\r
72 "convertedModel": $scope.convertModel(vidService.getModel()),
\r
73 "instance": vidService.getInstance()
\r
77 $scope.isCR = !_.isEmpty($scope.service.model.collectionResources);
\r
84 function preparePnfs() {
\r
85 var serviceInstance = {
\r
86 globalCustomerId: $location.search().subscriberId,
\r
87 serviceType: $location.search().serviceType,
\r
88 serviceInstanceId: $location.search().serviceInstanceId
\r
91 _setPnf(serviceInstance).then(function (data) {
\r
97 function prepareCr() {
\r
98 var serviceInstance = {
\r
99 globalCustomerId: $location.search().subscriberId,
\r
100 serviceType: $location.search().serviceType,
\r
101 serviceInstanceId: $location.search().serviceInstanceId
\r
104 _setCr(serviceInstance).then(function (data) {
\r
105 $scope.collectionResource = data;
\r
106 $scope.collections.push($scope.collectionResource.collection);
\r
107 $scope.networks.push($scope.collectionResource.networks[0]);
\r
111 $scope.returnVfModules = function (vnfInstance) {
\r
113 var svcModel = $scope.service.convertedModel;
\r
114 //var vnfModelInvariantUuid = vnfInstance[FIELD.ID.MODEL_INVAR_ID];
\r
115 var vnfModelVersionId = vnfInstance[FIELD.ID.MODEL_VERSION_ID]; // model uuid
\r
116 var vnfModelCustomizationUuid = vnfInstance[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
118 var vnfModel = null;
\r
120 if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {
\r
121 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {
\r
122 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
123 if (vnfModel !== undefined) {
\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
132 if (vnfModelVersionId != null) {
\r
133 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
134 if (vnfModel !== undefined) {
\r
135 if (!($scope.isObjectEmpty(vnfModel.vfModules))) {
\r
136 //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.vfModules, null, 4));
\r
137 return (vnfModel.vfModules);
\r
146 $scope.hasVfModules = function (vnfInstance) {
\r
147 if ($scope.returnVfModules(vnfInstance) != null) {
\r
152 $scope.returnVolumeGroups = function (vnfInstance) {
\r
154 var svcModel = $scope.service.convertedModel;
\r
156 //var vnfModelInvariantUuid = vnfInstance[FIELD.ID.MODEL_INVAR_ID];
\r
157 var vnfModelVersionId = vnfInstance[FIELD.ID.MODEL_VERSION_ID];
\r
158 var vnfModelCustomizationUuid = vnfInstance[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
160 var vnfModel = null;
\r
162 if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {
\r
163 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {
\r
164 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
165 if (vnfModel !== undefined) {
\r
167 if (!($scope.isObjectEmpty(vnfModel.volumeGroups))) {
\r
168 //console.log ("vnfModel.volumeGroups: "); console.log (JSON.stringify(vnfModel.volumeGroups, null, 4));
\r
169 return (vnfModel.volumeGroups);
\r
175 if (vnfModelVersionId != null) {
\r
176 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
177 if (!($scope.isObjectEmpty(vnfModel.volumeGroups))) {
\r
178 //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.volumeGroups, null, 4));
\r
179 return (vnfModel.volumeGroups);
\r
187 $scope.hasVolumeGroups = function (vnfInstance) {
\r
188 if ($scope.returnVolumeGroups(vnfInstance) != null) {
\r
193 $scope.deleteNetwork = function (serviceObject, network) {
\r
195 console.log("Removing Network " + network.name);
\r
197 //Send delete network request to MSO
\r
199 //var networks = this.service.instance.networks;
\r
201 //networks.splice(networks.indexOf(network), 1);
\r
203 //Retrieve updated data from A&AI
\r
204 var serviceInstance = serviceObject.object;
\r
206 setCurrentNetworkModelInfoFromScope(network);
\r
208 DataService.setInventoryItem(network.object);
\r
210 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
211 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
212 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
214 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
215 DataService.setServiceInstanceName($scope.service.instance.name);
\r
216 DataService.setServiceName($scope.service.model.service.name);
\r
217 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
218 DataService.setNetworkInstanceId(network.object[FIELD.ID.NETWORK_ID]);
\r
220 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
221 componentId: COMPONENT.NETWORK,
\r
222 callbackFunction: deleteOrResumeCallback,
\r
223 dialogMethod: COMPONENT.DELETE
\r
227 $scope.allowTransferToNewScreenAndShowButton = function (){
\r
228 if(featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_FLASH_MORE_ACTIONS_BUTTON_IN_OLD_VIEW_EDIT)) {
\r
229 return $scope.isPermitted;
\r
234 $scope.navigateToNewEditViewScreen = function(){
\r
235 window.location.href = 'serviceModels.htm#/servicePlanning/EDIT?' +
\r
236 'serviceModelId=' + _.get($scope, 'service.model.service.uuid') +
\r
237 '&subscriberId=' + $location.search().subscriberId +
\r
238 '&serviceType=' + $location.search().serviceType +
\r
239 '&serviceInstanceId=' + $location.search().serviceInstanceId;
\r
242 $scope.deleteService = function (serviceObject, serviceOrchestrationStatus) {
\r
244 var serviceInstance = serviceObject.object;
\r
246 console.log("Removing Service " + $scope.service.instance.name);
\r
248 if ($scope.isMacro()) {
\r
249 DataService.setALaCarte(false);
\r
252 DataService.setALaCarte(true);
\r
254 DataService.setMacro($scope.isMacro());
\r
255 DataService.setInventoryItem(serviceInstance);
\r
256 setCurrentServiceModelInfoFromScope();
\r
259 DataService.setSubscriberName(serviceObject[FIELD.ID.SUBSCRIBER_NAME]);
\r
260 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
261 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
263 DataService.setGlobalCustomerId(serviceObject[COMPONENT.GLOBAL_CUSTOMER_ID]);
\r
264 DataService.setServiceInstanceName($scope.service.instance.name);
\r
266 DataService.setServiceName($scope.service.model.service.name);
\r
268 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
270 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
271 componentId: COMPONENT.SERVICE,
\r
272 callbackFunction: deleteServiceInstanceCallbackFunction,
\r
273 dialogMethod: COMPONENT.DELETE,
\r
274 serviceStatus: serviceOrchestrationStatus
\r
279 function populate_popup_vfModule(serviceObject, vfModule, vnf) {
\r
280 var serviceInstance = serviceObject.object;
\r
282 DataService.setInventoryItem(vfModule.object);
\r
284 setCurrentVfModuleModelInfoFromScope(vnf, vfModule);
\r
285 var vfModuleInstanceID = vfModule.object[FIELD.ID.VF_MODULE_ID];
\r
286 if (vfModuleInstanceID == null) {
\r
287 vfModuleInstanceID = "";
\r
290 DataService.setVnfInstanceId(vnf.object[FIELD.ID.VNF_ID]);
\r
291 DataService.setVfModuleInstanceId(vfModuleInstanceID);
\r
293 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
294 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
295 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
297 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
298 DataService.setServiceInstanceName($scope.service.instance.name);
\r
300 DataService.setServiceName($scope.service.model.service.name);
\r
302 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
307 var openMsoModal = function (msoType, requestParams, callbackFunction, configuration) {
\r
308 modalInstance = $uibModal.open({
\r
309 templateUrl: 'app/vid/scripts/modals/mso-commit/mso-commit.html',
\r
310 controller: "msoCommitModalController",
\r
313 msoType: function () {
\r
316 requestParams: function () {
\r
317 requestParams.callbackFunction = callbackFunction;
\r
318 return requestParams;
\r
320 configuration: function () {
\r
321 return configuration;
\r
327 var openVfModuleWithHomingDataModal = function(action, vfModule) {
\r
328 modalInstance = $uibModal.open({
\r
329 controller: 'vfModuleActionModalController',
\r
330 templateUrl: 'app/vid/scripts/modals/vf-module-homing-data-action/vf-module-homing-data-action.html',
\r
333 action: function () {
\r
336 vfModule: function() {
\r
342 modalInstance.result.then(function (data) {
\r
343 if (data.msoType && data.requestParams) {
\r
344 openMsoModal(data.msoType, data.requestParams, deleteOrResumeCallback, null);
\r
349 function getLcpCloudRegionTenantList() {
\r
350 AaiService.getLcpCloudRegionTenantList(DataService
\r
351 .getGlobalCustomerId(), DataService.getServiceType(), function(
\r
353 $scope.lcpAndTenant = response;
\r
354 $scope.isFeatureFlagCloudOwner = featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST);
\r
355 $scope.lcpRegionList = _.uniqBy(response, 'cloudRegionId');
\r
359 $scope.deleteVfModule = function (serviceObject, vfModule, vnf) {
\r
360 $scope.isSoftDeleteEnabled = true;
\r
362 populate_popup_vfModule(serviceObject, vfModule, vnf);
\r
364 if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_SOFT_DELETE_ALACARTE_VF_MODULE)) {
\r
366 if (DataService.getLoggedInUserId()) {
\r
367 openVfModuleWithHomingDataModal(COMPONENT.DELETE, vfModule);
\r
370 AaiService.getLoggedInUserID(function (response) {
\r
371 var userID = response.data;
\r
372 DataService.setLoggedInUserId(userID);
\r
373 openVfModuleWithHomingDataModal(COMPONENT.DELETE, vfModule);
\r
378 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
379 componentId: COMPONENT.VF_MODULE,
\r
380 callbackFunction: deleteOrResumeCallback,
\r
381 dialogMethod: COMPONENT.DELETE
\r
384 console.log("Removing VF-Module", vfModule);
\r
387 function setCurrentServiceModelInfoFromScope() {
\r
388 DataService.setModelInfo(COMPONENT.SERVICE, {
\r
389 "modelInvariantId": $scope.service.model.service.invariantUuid,
\r
390 "modelVersion": $scope.service.model.service.version,
\r
391 "modelNameVersionId": $scope.service.model.service.uuid,
\r
392 "modelName": $scope.service.model.service.name,
\r
397 function setCurrentVNFModelInfo(vnf) {
\r
398 var svcModel = $scope.service.convertedModel;
\r
400 var vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
401 var vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
402 if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {
\r
403 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {
\r
404 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
407 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
409 if (!($scope.isObjectEmpty(vnfModel))) {
\r
411 DataService.setModelInfo(COMPONENT.VNF, {
\r
412 "modelInvariantId": vnfModel.invariantUuid,
\r
413 "modelVersion": vnfModel.version,
\r
414 "modelNameVersionId": vnfModel.uuid,
\r
415 "modelCustomizationName": vnfModel.modelCustomizationName,
\r
416 "customizationUuid": vnfModel.customizationUuid,
\r
417 "modelName": vnfModel.name,
\r
426 function setCurrentNetworkModelInfoFromScope(network) {
\r
427 var svcModel = $scope.service.convertedModel;
\r
429 // set model default and override later if found
\r
430 DataService.setModelInfo(COMPONENT.NETWORK, {});
\r
432 if (network.object != null) {
\r
434 //var netModelInvariantUuid = network.object[FIELD.ID.MODEL_INVAR_ID];
\r
435 var netModelVersionId = network.object[FIELD.ID.MODEL_VERSION_ID]; // model uuid
\r
436 var netModelCustomizationUuid = network.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
438 if (UtilityService.hasContents(netModelCustomizationUuid)) {
\r
439 // set it to what came from a&ai
\r
440 DataService.setResCustomizationUuid(netModelCustomizationUuid);
\r
443 if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.networks)))) {
\r
444 if ((svcModel.isNewFlow) && (UtilityService.hasContents(netModelCustomizationUuid))) {
\r
445 netModel = svcModel.networks[netModelCustomizationUuid];
\r
449 if (UtilityService.hasContents(netModelVersionId)) {
\r
450 netModel = svcModel.networks[netModelVersionId];
\r
456 if (!($scope.isObjectEmpty(netModel))) {
\r
457 DataService.setModelInfo(COMPONENT.NETWORK, {
\r
458 "modelInvariantId": netModel.invariantUuid,
\r
459 "modelVersion": netModel.version,
\r
460 "modelNameVersionId": netModel.uuid,
\r
461 "modelCustomizationName": netModel.modelCustomizationName,
\r
462 "customizationUuid": netModel.customizationUuid,
\r
463 "modelName": netModel.name,
\r
469 function setCurrentVfModuleModelInfoFromScope(vnf, vfModule) {
\r
471 var svcModel = $scope.service.convertedModel;
\r
473 //var vnfModelInvariantUuid = vnf.object[FIELD.ID.MODEL_INVAR_ID];
\r
474 var vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
475 var vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
476 var vnfModel = null;
\r
477 var vfModuleModel = null;
\r
479 DataService.setModelInfo(COMPONENT.VF_MODULE, {
\r
480 "modelInvariantId": "",
\r
481 "modelVersion": "",
\r
482 "modelNameVersionId": "",
\r
483 "modelCustomizationName": "",
\r
484 "customizationUuid": "",
\r
489 if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {
\r
490 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {
\r
491 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
493 var vfModuleCustomizationUuid = vfModule.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
494 if (!($scope.isObjectEmpty(vnfModel)) && !($scope.isObjectEmpty(vnfModel.vfModules)) && UtilityService.hasContents(vfModuleCustomizationUuid)) {
\r
496 vfModuleModel = vnfModel.vfModules[vfModuleCustomizationUuid];
\r
502 if (vnfModelVersionId != null) {
\r
503 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
505 //var vfModuleInvariantUuid = vfModule.object[FIELD.ID.MODEL_INVAR_ID];
\r
506 var vfModuleModelVersionId = vfModule.object[FIELD.ID.MODEL_VERSION_ID];
\r
507 if ((!($scope.isObjectEmpty(vnfModel))) && (!($scope.isObjectEmpty(vnfModel.vfModules))) &&
\r
508 UtilityService.hasContents(vfModuleModelVersionId)) {
\r
509 vfModuleModel = vnfModel.vfModules[vfModuleModelVersionId];
\r
512 if (!($scope.isObjectEmpty(vfModuleModel))) {
\r
513 DataService.setModelInfo(COMPONENT.VF_MODULE, {
\r
514 "modelInvariantId": vfModuleModel.invariantUuid,
\r
515 "modelVersion": vfModuleModel.version,
\r
516 "modelNameVersionId": vfModuleModel.uuid,
\r
517 "modelCustomizationName": vfModuleModel.modelCustomizationName,
\r
518 "customizationUuid": vfModuleModel.customizationUuid,
\r
519 "modelName": vfModuleModel.name,
\r
526 function setCurrentVolumeGroupModelInfoFromScope(vnf, vfModule) {
\r
527 var svcModel = $scope.service.convertedModel;
\r
529 var vnfModelCustomizationUuid = null;
\r
530 var vnfModel = null;
\r
531 var vnfModelVersionId = null;
\r
533 vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
534 vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
536 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
\r
537 "modelInvariantId": "",
\r
538 "modelVersion": "",
\r
539 "modelNameVersionId": "",
\r
540 "modelCustomizationName": "",
\r
541 "customizationUuid": "",
\r
546 if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {
\r
547 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {
\r
548 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
551 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
556 // volume groups don't have model-invariant-id/version in a&ai.
\r
557 // Their model-invariant-id/version is the one for the associated vfModule
\r
559 var vfModuleModelVersionId = vfModule.object[FIELD.ID.MODEL_VERSION_ID];
\r
560 var vfModuleCustomizationUuid = vfModule.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
561 var volGroupModel = null;
\r
563 if (!($scope.isObjectEmpty(vnfModel)) && !($scope.isObjectEmpty(vnfModel.volumeGroups))) {
\r
564 if ((svcModel.isNewFlow) && (UtilityService.hasContents(vfModuleCustomizationUuid))) {
\r
565 volGroupModel = vnfModel.volumeGroups[vfModuleCustomizationUuid];
\r
568 volGroupModel = vnfModel.volumeGroups[vfModuleModelVersionId];
\r
570 if (!($scope.isObjectEmpty(volGroupModel))) {
\r
571 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
\r
572 "modelInvariantId": volGroupModel.invariantUuid,
\r
573 "modelVersion": volGroupModel.version,
\r
574 "modelNameVersionId": volGroupModel.uuid,
\r
575 "modelCustomizationName": volGroupModel.modelCustomizationName,
\r
576 "customizationUuid": volGroupModel.customizationUuid,
\r
577 "modelName": volGroupModel.name,
\r
585 function setCurrentVolumeGroupModelInfoByVfModuleFromScope(vnf, volumeGroup) {
\r
586 var svcModel = $scope.service.convertedModel;
\r
588 var vnfModelCustomizationUuid = null;
\r
589 var vnfModel = null;
\r
590 var vnfModelVersionId = null;
\r
592 vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
593 vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
595 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
\r
596 "modelInvariantId": "",
\r
597 "modelVersion": "",
\r
598 "modelNameVersionId": "",
\r
599 "modelCustomizationName": "",
\r
600 "customizationUuid": "",
\r
605 if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {
\r
606 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {
\r
607 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
610 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
615 // volume groups don't have model-invariant-id/version in a&ai.
\r
616 // Their model-invariant-id/version is the one for the associated vfModule
\r
618 var vfModuleModelVersionId = volumeGroup.object[FIELD.ID.VF_MODULE_MODEL_VERSION_ID];
\r
619 var vfModuleCustomizationUuid = volumeGroup.object[FIELD.ID.VF_MODULE_MODEL_CUSTOMIZATION_ID];
\r
620 var volGroupModel = null;
\r
621 if ((!($scope.isObjectEmpty(vnfModel))) && (!($scope.isObjectEmpty(vnfModel.volumeGroups)))) {
\r
622 if ((svcModel.isNewFlow) && (UtilityService.hasContents(vfModuleCustomizationUuid))) {
\r
623 volGroupModel = vnfModel.volumeGroups[vfModuleCustomizationUuid];
\r
626 volGroupModel = vnfModel.volumeGroups[vfModuleModelVersionId];
\r
628 if (!($scope.isObjectEmpty(volGroupModel))) {
\r
629 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
\r
630 "modelInvariantId": volGroupModel.invariantUuid,
\r
631 "modelVersion": volGroupModel.version,
\r
632 "modelNameVersionId": volGroupModel.uuid,
\r
633 "modelCustomizationName": volGroupModel.modelCustomizationName,
\r
634 "customizationUuid": volGroupModel.customizationUuid,
\r
635 "modelName": volGroupModel.name,
\r
643 $scope.deleteVnf = function (serviceObject, vnf) {
\r
644 console.log("Removing VNF " + vnf.name);
\r
646 var serviceInstance = serviceObject.object;
\r
647 var svcModel = $scope.service.convertedModel;
\r
648 DataService.setInventoryItem(vnf.object);
\r
650 /*var vnftype = vnf.object['vnf-type'];
\r
651 if (vnftype == null)
\r
655 var n = vnftype.search("/");
\r
657 vnftype = vnftype.substring(n+1);
\r
660 var svcModel = $scope.service.convertedModel;
\r
661 var vnfModelInvariantUuid = null;
\r
662 var vnfModelVersion = null;
\r
663 var vnfModelCustomizationUuid = null;
\r
664 var vnfModel = null;
\r
665 var vnfModelVersionId = null;
\r
667 vnfModelInvariantUuid = vnf.object[FIELD.ID.MODEL_INVAR_ID];
\r
668 vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
669 vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
671 DataService.setModelInfo(COMPONENT.VNF, {
\r
672 "modelInvariantId": vnfModelInvariantUuid,
\r
673 "modelVersion": "",
\r
674 "modelNameVersionId": vnfModelVersionId,
\r
675 "modelCustomizationName": "",
\r
676 "customizationUuid": vnfModelCustomizationUuid,
\r
681 if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {
\r
682 if ((svcModel.isNewFlow) && (vnfModelCustomizationUuid != null)) {
\r
683 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
686 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
688 //console.log ( "vnf models: "); console.log ( JSON.stringify ($scope.service.convertedModel.vnfs, null, 4) );
\r
689 if (!($scope.isObjectEmpty(vnfModel))) {
\r
691 DataService.setModelInfo(COMPONENT.VNF, {
\r
692 "modelInvariantId": vnfModel.invariantUuid,
\r
693 "modelVersion": vnfModel.version,
\r
694 "modelNameVersionId": vnfModel.uuid,
\r
695 "modelCustomizationName": vnfModel.modelCustomizationName,
\r
696 "customizationUuid": vnfModel.customizationUuid,
\r
697 "modelName": vnfModel.name,
\r
703 DataService.setVnfInstanceId(vnf.object[FIELD.ID.VNF_ID]);
\r
705 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
706 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
707 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
709 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
710 DataService.setServiceInstanceName($scope.service.instance.name);
\r
712 DataService.setServiceName($scope.service.model.service.name);
\r
714 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
716 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
717 componentId: COMPONENT.VNF,
\r
718 callbackFunction: deleteOrResumeCallback,
\r
719 dialogMethod: COMPONENT.DELETE
\r
724 $scope.deleteVolumeGroup = function (serviceObject, vnf, vfModule, volumeGroup) {
\r
726 console.log("Removing Volume Group " + volumeGroup.name);
\r
727 var haveModel = false;
\r
729 var serviceInstance = serviceObject.object;
\r
731 setCurrentVolumeGroupModelInfoFromScope(vnf, vfModule);
\r
733 DataService.setInventoryItem(volumeGroup.object);
\r
735 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
736 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
737 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
739 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
740 DataService.setServiceInstanceName($scope.service.instance.name);
\r
742 DataService.setServiceName($scope.service.model.service.name);
\r
744 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
745 DataService.setVnfInstanceId(vnf.nodeId);
\r
746 DataService.setVolumeGroupInstanceId(volumeGroup.nodeId);
\r
748 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
749 componentId: COMPONENT.VOLUME_GROUP,
\r
750 dialogMethod: COMPONENT.DELETE
\r
754 $scope.deleteVnfVolumeGroup = function (serviceObject, vnf, volumeGroup) {
\r
756 console.log("Removing Volume Group " + volumeGroup.name);
\r
757 var serviceInstance = serviceObject.object;
\r
759 DataService.setInventoryItem(volumeGroup.object);
\r
761 var svcModel = $scope.service.convertedModel;
\r
763 var vnfModelInvariantUuid = vnf.object[FIELD.ID.MODEL_INVAR_ID];
\r
764 var vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
765 var vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
767 var volGroupModelInvariantUuid = volumeGroup.object[FIELD.ID.MODEL_INVAR_ID];
\r
768 var volGroupModelVersionId = volumeGroup.object[FIELD.ID.MODEL_VERSION_ID];
\r
769 var volGroupModelCustomizationUuid = volumeGroup.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
771 var vnfModel = null;
\r
772 var volGroupModel = null;
\r
774 // send an empty model by default since model is not required for deletes
\r
775 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {});
\r
777 if (svcModel.isNewFlow) {
\r
778 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
779 if (UtilityService.hasContents(volGroupModelCustomizationUuid)) {
\r
780 volGroupModel = vnfModel.volumeGroups[volGroupModelCustomizationUuid];
\r
785 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
786 if (UtilityService.hasContents(volGroupModelVersionId)) {
\r
787 volGroupModel = vnfModel.volumeGroups[volGroupModelVersionId];
\r
790 if (!($scope.isObjectEmpty(volGroupModel))) {
\r
791 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
\r
792 "modelInvariantId": volGroupModel.invariantUuid,
\r
793 "modelVersion": volGroupModel.version,
\r
794 "modelNameVersionId": volGroupModel.uuid,
\r
795 "modelName": volGroupModel.name,
\r
796 "modelCustomizationName": volGroupModel.modelCustomizationName,
\r
797 "customizationUuid": volGroupModel.customizationUuid,
\r
802 DataService.setVnfInstanceId(vnf.object[FIELD.ID.VNF_ID]);
\r
804 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
805 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
806 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
808 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
809 DataService.setServiceInstanceName($scope.service.instance.name);
\r
811 DataService.setServiceName($scope.service.model.service.name);
\r
813 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
814 DataService.setVnfInstanceId(vnf.nodeId);
\r
815 DataService.setVolumeGroupInstanceId(volumeGroup.nodeId);
\r
817 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
818 componentId: COMPONENT.VOLUME_GROUP,
\r
819 callbackFunction: deleteOrResumeCallback,
\r
820 dialogMethod: COMPONENT.DELETE
\r
824 $scope.describeNetwork = function (serviceObject, networkObject) {
\r
825 var serviceInstance = serviceObject.object;
\r
826 var network = networkObject.object;
\r
827 //console.log ("networkObject="); console.log (JSON.stringify(networkObject, null, 4));
\r
829 DataService.setResCustomizationUuid(" ");
\r
831 setCurrentServiceModelInfoFromScope();
\r
832 setCurrentNetworkModelInfoFromScope(networkObject);
\r
834 DataService.setNetworkInstanceId(network[FIELD.ID.NETWORK_ID]);
\r
835 DataService.setInventoryItem(networkObject);
\r
836 DataService.setSubscriberName(serviceObject.subscriberName);
\r
837 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
838 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
840 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
841 componentId: COMPONENT.NETWORK
\r
845 // for service instance id - no need for this!
\r
846 $scope.describeService = function (serviceObject) {
\r
847 var serviceInstance = serviceObject.object;
\r
848 setCurrentServiceModelInfoFromScope();
\r
850 DataService.setInventoryItem(serviceInstance);
\r
851 //DataService.setModelInfo(serviceInstance['service-instance-id'], serviceInstance);
\r
853 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
854 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
855 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
857 //Display popup with additional service information
\r
858 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
859 componentId: COMPONENT.SERVICE
\r
864 $scope.describeVfModule = function (serviceObject, vfModuleObject, vnf) {
\r
865 var serviceInstance = serviceObject.object;
\r
866 var vfModule = vfModuleObject.object;
\r
868 /*var vfModuleInvariantUuid = vfModule[FIELD.ID.MODEL_INVAR_ID];
\r
869 var vfModuleModelVersionId = vfModule[FIELD.ID.MODEL_VERSION_ID];*/
\r
870 var vfModuleCustomizationUuid = vfModule[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
872 setCurrentServiceModelInfoFromScope();
\r
873 setCurrentVfModuleModelInfoFromScope(vnf, vfModuleObject);
\r
875 DataService.setCustomizationUuid(" ");
\r
876 if (UtilityService.hasContents(vfModuleCustomizationUuid)) {
\r
877 DataService.setCustomizationUuid(vfModuleCustomizationUuid);
\r
880 //Display popup with additional VF-Module information
\r
881 DataService.setVfModuleInstanceId(vfModule[FIELD.ID.VF_MODULE_ID]);
\r
882 DataService.setInventoryItem(vfModule);
\r
884 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
885 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
886 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
888 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
889 componentId: COMPONENT.VF_MODULE
\r
893 $scope.getStatusOfVnf = function (serviceObject, vnfObject) {
\r
894 var serviceInstance = serviceObject.object;
\r
895 var vnf = vnfObject.object;
\r
897 DataService.setVnfInstanceId(vnf[FIELD.ID.VNF_ID]);
\r
898 DataService.setInventoryItem(vnf);
\r
900 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
901 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
902 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
903 DataService.setServiceInstanceName(serviceInstance[FIELD.ID.SERVICE_INSTANCE_NAME]);
\r
905 $scope.$broadcast(COMPONENT.COMPONENT_STATUS, {
\r
906 componentId: COMPONENT.VNF,
\r
907 callbackFunction: updateProvStatusVnfCallbackFunction
\r
911 $scope.describeVnf = function (serviceObject, vnfObject) {
\r
912 var serviceInstance = serviceObject.object;
\r
913 var vnf = vnfObject.object;
\r
914 DataService.setResCustomizationUuid(" ");
\r
916 //var vnfInvariantUuid = vnf[FIELD.ID.MODEL_INVAR_ID];
\r
917 //var vnfVersionId = vnf[FIELD.ID.MODEL_VERSION_ID];
\r
918 var vnfCustomizationUuid = vnf[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
920 if (UtilityService.hasContents(vnfCustomizationUuid)) {
\r
921 DataService.setResCustomizationUuid(vnfCustomizationUuid);
\r
924 setCurrentServiceModelInfoFromScope();
\r
925 setCurrentVNFModelInfo(vnfObject);
\r
927 //Display popup with additional VNF information
\r
928 DataService.setVnfInstanceId(vnf[FIELD.ID.VNF_ID]);
\r
929 DataService.setInventoryItem(vnf);
\r
931 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
932 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
933 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
935 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
936 componentId: COMPONENT.VNF
\r
940 $scope.describeVolumeGroup = function (serviceObject, vnf, volumeGroupObject) {
\r
942 var serviceInstance = serviceObject.object;
\r
943 var volumeGroup = volumeGroupObject.object;
\r
945 var volGroupCustomizationUuid = volumeGroup[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
947 setCurrentServiceModelInfoFromScope();
\r
948 setCurrentVolumeGroupModelInfoByVfModuleFromScope(vnf, volumeGroupObject);
\r
950 DataService.setCustomizationUuid(" ");
\r
951 if (UtilityService.hasContents(volGroupCustomizationUuid)) {
\r
952 DataService.setCustomizationUuid(volGroupCustomizationUuid);
\r
954 DataService.setVolumeGroupInstanceId(volumeGroup[FIELD.ID.VOLUME_GROUP_ID]);
\r
955 DataService.setInventoryItem(volumeGroup);
\r
957 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
958 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
959 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
962 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
963 componentId: COMPONENT.VOLUME_GROUP
\r
967 $scope.addNetworkInstance = function (netModel, existingVnfs) {
\r
969 // For networks we assume that we always follow the new flow
\r
970 console.log("Adding network to service instance" + this.service.instance.name);
\r
971 if (VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED && (UtilityService.hasContents(existingVnfs)) && (existingVnfs.length > 0)) {
\r
972 var msg = VnfService.isVnfListStatusValid(existingVnfs);
\r
979 DataService.setSubscriberName($scope.service.instance.subscriberName);
\r
980 DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
\r
981 DataService.setServiceType($scope.service.instance.serviceType);
\r
982 DataService.setServiceInstanceName($scope.service.instance.name);
\r
983 DataService.setServiceInstanceId($scope.service.instance.id);
\r
984 DataService.setServiceName($scope.service.model.service.name);
\r
986 DataService.setModelInfo(COMPONENT.NETWORK, {
\r
987 "modelType": "network",
\r
988 "modelInvariantId": netModel.invariantUuid,
\r
989 "modelVersion": netModel.version,
\r
990 "modelNameVersionId": netModel.uuid,
\r
991 "modelName": netModel.name,
\r
992 "modelCustomizationName": netModel.modelCustomizationName,
\r
993 "customizationUuid": netModel.customizationUuid,
\r
995 "displayInputs": netModel.displayInputs
\r
997 setCurrentServiceModelInfoFromScope();
\r
1000 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {
\r
1001 componentId: COMPONENT.NETWORK,
\r
1002 callbackFunction: createVnfCallbackFunction
\r
1006 $scope.addVnfInstance = function (vnf, existingVnfs) {
\r
1008 if (VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED && (UtilityService.hasContents(existingVnfs)) && (existingVnfs.length > 0)) {
\r
1009 var msg = VnfService.isVnfListStatusValid(existingVnfs);
\r
1016 var isVfc = false;
\r
1018 _.map($scope.service.model.vnfs, function (value, key) {
\r
1019 if (value.uuid == vnf.uuid) {
\r
1020 if (!_.isEmpty(value.vfcInstanceGroups)) {
\r
1023 serviceModelId: $scope.service.model.service.uuid,
\r
1024 serviceInstanceID: $scope.service.instance.id,
\r
1025 globalCustomerId: $scope.service.instance.globalCustomerId,
\r
1026 serviceType: $scope.service.instance.serviceType,
\r
1027 serviceInstanceName: $scope.service.instance.name,
\r
1028 modelCustomizationName: value.modelCustomizationName,
\r
1029 modelCustomizationId: value.customizationUuid,
\r
1030 subscriberName: $scope.service.instance.subscriberName
\r
1033 $scope.$broadcast(COMPONENT.IFRAME_DIALOG, queryData);
\r
1039 DataService.setSubscriberName($scope.service.instance.subscriberName);
\r
1040 DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
\r
1041 DataService.setServiceType($scope.service.instance.serviceType);
\r
1042 DataService.setServiceInstanceName($scope.service.instance.name);
\r
1043 DataService.setServiceInstanceId($scope.service.instance.id);
\r
1044 DataService.setServiceName($scope.service.model.service.name);
\r
1046 console.log("existingVnfs: ");
\r
1047 console.log(JSON.stringify(existingVnfs, null, 4));
\r
1048 console.log("existingVnfs: ");
\r
1049 console.log(JSON.stringify(existingVnfs, null, 4));
\r
1050 var vnf_type = "";
\r
1051 var vnf_role = "";
\r
1052 var vnf_function = "";
\r
1053 var vnf_code = "";
\r
1055 if (UtilityService.hasContents(vnf.nfType)) {
\r
1056 vnf_type = vnf.nfType;
\r
1058 if (UtilityService.hasContents(vnf.nfRole)) {
\r
1059 vnf_role = vnf.nfRole;
\r
1061 if (UtilityService.hasContents(vnf.nfFunction)) {
\r
1062 vnf_function = vnf.nfFunction;
\r
1064 if (UtilityService.hasContents(vnf.nfCode)) {
\r
1065 vnf_code = vnf.nfCode;
\r
1067 DataService.setModelInfo(COMPONENT.VNF, {
\r
1068 "modelType": vnf.isPnf ? "pnf" : "vnf",
\r
1069 "modelInvariantId": vnf.invariantUuid,
\r
1070 "modelVersion": vnf.version,
\r
1071 "modelNameVersionId": vnf.uuid,
\r
1072 "modelName": vnf.name,
\r
1073 "modelCustomizationName": vnf.modelCustomizationName,
\r
1074 "customizationUuid": vnf.customizationUuid,
\r
1076 "displayInputs": vnf.displayInputs,
\r
1077 "vnfType": vnf_type,
\r
1078 "vnfRole": vnf_role,
\r
1079 "vnfFunction": vnf_function,
\r
1080 "vnfCode": vnf_code,
\r
1081 "properties": vnf.properties
\r
1084 DataService.setModelInstanceName($scope.service.model.service.name);
\r
1085 setCurrentServiceModelInfoFromScope();
\r
1087 if (vnf.isConfig) {
\r
1088 DataService.setServiceProxies($scope.service.model.serviceProxies);
\r
1089 DataService.setSourceServiceProxies(vnf.sourceNodes);
\r
1090 DataService.setCollectorServiceProxies(vnf.collectorNodes);
\r
1091 DataService.setConfigurationByPolicy(vnf.isConfigurationByPolicy);
\r
1092 $location.path("/addNetworkNode");
\r
1093 } else if (vnf.isPnf) {
\r
1094 $location.path("/pnfSearchAssociation");
\r
1095 } else if (isVfc) {
\r
1098 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {
\r
1099 componentId: COMPONENT.VNF,
\r
1100 callbackFunction: createVnfCallbackFunction
\r
1105 $scope.addVfModuleInstance = function (vnfInstance, vfModuleModel) {
\r
1107 if (VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED) {
\r
1108 var msg = VnfService.isVnfStatusValid(vnfInstance);
\r
1115 var svcModel = $scope.service.convertedModel;
\r
1116 DataService.setSubscriberName($scope.service.instance.subscriberName);
\r
1117 DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
\r
1118 DataService.setServiceType($scope.service.instance.serviceType);
\r
1119 DataService.setServiceInstanceName($scope.service.instance.name);
\r
1120 DataService.setServiceInstanceId($scope.service.instance.id);
\r
1121 DataService.setServiceName($scope.service.model.service.name);
\r
1123 var vnfModelInvariantUuid = vnfInstance.object[FIELD.ID.MODEL_INVAR_ID];
\r
1124 var vnfModelVersionId = vnfInstance.object[FIELD.ID.MODEL_VERSION_ID];
\r
1125 var vnfModelCustomizationUuid = vnfInstance.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
1126 var vnfModel = null;
\r
1127 if (svcModel.isNewFlow) {
\r
1128 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
1131 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
1134 var availableVolumeGroupList = [];
\r
1135 angular.forEach(vnfInstance[FIELD.ID.AVAILABLEVOLUMEGROUPS], function (volumeGroupInstance, key) {
\r
1136 availableVolumeGroupList.push({"instance": volumeGroupInstance});
\r
1139 DataService.setAvailableVolumeGroupList(availableVolumeGroupList);
\r
1140 setCurrentServiceModelInfoFromScope();
\r
1142 DataService.setVnfInstanceId(vnfInstance.object[FIELD.ID.VNF_ID]);
\r
1144 DataService.setModelInfo(COMPONENT.VNF, {
\r
1145 "modelInvariantId": vnfModel.invariantUuid,
\r
1146 "modelVersion": vnfModel.version,
\r
1147 "modelNameVersionId": vnfModel.uuid,
\r
1148 "modelName": vnfModel.name,
\r
1149 "modelCustomizationName": vnfModel.modelCustomizationName,
\r
1150 "customizationUuid": vnfModel.customizationUuid,
\r
1154 DataService.setModelInfo(COMPONENT.VF_MODULE, {
\r
1155 "modelInvariantId": vfModuleModel.invariantUuid,
\r
1156 "modelVersion": vfModuleModel.version,
\r
1157 "modelNameVersionId": vfModuleModel.uuid,
\r
1158 "customizationUuid": vfModuleModel.customizationUuid,
\r
1159 "modelCustomizationName": vfModuleModel.modelCustomizationName,
\r
1160 "modelName": vfModuleModel.name,
\r
1164 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {
\r
1165 componentId: COMPONENT.VF_MODULE,
\r
1166 callbackFunction: createVfModuleCallbackFunction
\r
1171 $scope.addVolumeGroupInstance = function (vnfInstance, volumeGroupModel) {
\r
1172 if (VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED) {
\r
1173 var msg = VnfService.isVnfStatusValid(vnfInstance);
\r
1179 var svcModel = $scope.service.convertedModel;
\r
1180 DataService.setSubscriberName($scope.service.instance.subscriberName);
\r
1181 DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
\r
1182 DataService.setServiceType($scope.service.instance.serviceType);
\r
1183 DataService.setServiceInstanceName($scope.service.instance.name);
\r
1184 DataService.setServiceInstanceId($scope.service.instance.id);
\r
1185 DataService.setServiceName($scope.service.model.service.name);
\r
1186 setCurrentServiceModelInfoFromScope();
\r
1188 DataService.setModelInfo(COMPONENT.SERVICE, {
\r
1189 "modelInvariantId": $scope.service.model.service.invariantUuid,
\r
1190 "modelVersion": $scope.service.model.service.version,
\r
1191 "modelNameVersionId": $scope.service.model.service.uuid,
\r
1192 "modelName": $scope.service.model.service.name,
\r
1196 DataService.setVnfInstanceId(vnfInstance.object[FIELD.ID.VNF_ID]);
\r
1198 var vnfModelInvariantUuid = vnfInstance.object[FIELD.ID.MODEL_INVAR_ID];
\r
1199 var vnfModelVersionId = vnfInstance.object[FIELD.ID.MODEL_VERSION_ID];
\r
1200 var vnfCustomizationUuid = vnfInstance.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
1201 var vnfModel = null;
\r
1203 if (svcModel.isNewFlow) {
\r
1204 vnfModel = svcModel.vnfs[vnfCustomizationUuid];
\r
1207 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
1210 DataService.setModelInfo(COMPONENT.VNF, {
\r
1211 "modelInvariantId": vnfModel.invariantUuid,
\r
1212 "modelVersion": vnfModel.version,
\r
1213 "modelNameVersionId": vnfModel.uuid,
\r
1214 "modelName": vnfModel.name,
\r
1215 "modelCustomizationName": vnfModel.modelCustomizationName,
\r
1216 "customizationUuid": vnfModel.customizationUuid,
\r
1220 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
\r
1221 "modelInvariantId": volumeGroupModel.invariantUuid,
\r
1222 "modelVersion": volumeGroupModel.version,
\r
1223 "modelNameVersionId": volumeGroupModel.uuid,
\r
1224 "modelName": volumeGroupModel.name,
\r
1225 "modelCustomizationName": volumeGroupModel.modelCustomizationName,
\r
1226 "customizationUuid": volumeGroupModel.customizationUuid,
\r
1230 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {
\r
1231 componentId: COMPONENT.VOLUME_GROUP,
\r
1232 callbackFunction: createVolumeGroupCallbackFunction
\r
1236 $scope.resume = function (serviceObject, vfModule, vnfModel) {
\r
1237 populate_popup_vfModule(serviceObject, vfModule, vnfModel);
\r
1238 setCurrentVNFModelInfo(vnfModel);
\r
1240 var availableVolumeGroupList = [];
\r
1241 angular.forEach(vfModule.volumeGroups, function (volumeGroupInstance, key) {
\r
1242 availableVolumeGroupList.push({"instance": volumeGroupInstance});
\r
1245 DataService.setAvailableVolumeGroupList(availableVolumeGroupList);
\r
1247 DataService.setVfModuleInstanceName(vfModule.object[FIELD.ID.VF_MODULE_NAME]);
\r
1248 setCurrentServiceModelInfoFromScope();
\r
1250 if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_SOFT_DELETE_ALACARTE_VF_MODULE)) {
\r
1252 if (DataService.getLoggedInUserId()) {
\r
1253 openVfModuleWithHomingDataModal(COMPONENT.RESUME, vfModule);
\r
1256 AaiService.getLoggedInUserID(function (response) {
\r
1257 var userID = response.data;
\r
1258 DataService.setLoggedInUserId(userID);
\r
1259 openVfModuleWithHomingDataModal(COMPONENT.RESUME, vfModule);
\r
1264 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
1265 componentId: COMPONENT.VF_MODULE,
\r
1266 volumeGroups: vfModule.volumeGroups,
\r
1267 callbackFunction: deleteOrResumeCallback,
\r
1268 dialogMethod: COMPONENT.RESUME
\r
1273 $scope.deleteConfiguration = function (serviceObject, configuration) {
\r
1274 console.log("Deleting Configuration " + configuration.name);
\r
1276 var serviceInstance = serviceObject.object;
\r
1277 var svcModel = $scope.service.convertedModel;
\r
1279 DataService.setInventoryItem(configuration.object);
\r
1280 // set model default and override later if found
\r
1281 DataService.setModelInfo(COMPONENT.CONFIGURATION, {});
\r
1283 if (configuration.object != null) {
\r
1285 //var netModelInvariantUuid = network.object[FIELD.ID.MODEL_INVAR_ID];
\r
1286 var configModelVersionId = configuration.object[FIELD.ID.MODEL_VERSION_ID]; // model uuid
\r
1287 var configModelCustomizationUuid = configuration.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
1289 //configurations added to vnfs list, in order to be part of the "Add VNF" drop-down list
\r
1290 if ((!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.vnfs)))) {
\r
1291 if ((svcModel.isNewFlow) && (UtilityService.hasContents(configModelCustomizationUuid))) {
\r
1292 configModel = svcModel.vnfs[configModelCustomizationUuid];
\r
1296 if (UtilityService.hasContents(configModelVersionId)) {
\r
1297 configModel = svcModel.vnfs[configModelVersionId];
\r
1303 if (!($scope.isObjectEmpty(configModel))) {
\r
1304 DataService.setModelInfo(COMPONENT.CONFIGURATION, {
\r
1305 "modelInvariantId": configModel.invariantUuid,
\r
1306 "modelVersion": configModel.version,
\r
1307 "modelNameVersionId": configModel.uuid,
\r
1308 "modelCustomizationName": configModel.modelCustomizationName,
\r
1309 "customizationUuid": configModel.customizationUuid,
\r
1310 "modelName": configModel.name,
\r
1315 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
1316 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
1317 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
1319 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
1320 DataService.setServiceInstanceName($scope.service.instance.name);
\r
1321 DataService.setServiceName($scope.service.model.service.name);
\r
1322 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
1323 DataService.setConfigurationInstanceId(configuration.object[FIELD.ID.CONFIGURATION_ID]);
\r
1325 $scope.$broadcast(COMPONENT.DELETE_RESUME_COMPONENT, {
\r
1326 componentId: COMPONENT.CONFIGURATION,
\r
1327 dialogMethod: COMPONENT.DELETE,
\r
1328 callbackFunction: deleteCallbackFunction
\r
1332 var deleteCallbackFunction = function () {
\r
1336 $scope.resetProgress = function () {
\r
1337 $scope.percentProgress = 0;
\r
1338 $scope.progressClass = FIELD.STYLE.PROGRESS_BAR_INFO;
\r
1341 $scope.setProgress = function (percentProgress) {
\r
1342 percentProgress = parseInt(percentProgress);
\r
1343 if (percentProgress >= 100) {
\r
1344 $scope.progressClass = FIELD.STYLE.PROGRESS_BAR_SUCCESS;
\r
1347 if (percentProgress < $scope.percentProgress) {
\r
1351 $scope.percentProgress = percentProgress;
\r
1352 $scope.progressWidth = {width: percentProgress + "%"};
\r
1353 if (percentProgress >= 5) {
\r
1354 $scope.progressText = percentProgress + " %";
\r
1356 // Hidden since color combination is barely visible when progress portion is narrow.
\r
1357 $scope.progressText = "";
\r
1360 $scope.isObjectEmpty = function (o) {
\r
1362 if (UtilityService.hasContents(o)) {
\r
1363 var keys = Object.keys(o);
\r
1364 len = keys.length;
\r
1376 $scope.isMacro = function () {
\r
1377 return $scope.service && AsdcService.isMacro($scope.service.model);
\r
1379 $scope.reloadRoute = function () {
\r
1390 * set the controller pnf param using api call
\r
1393 function _setPnf(data) { // data is the $scope.service.instance object
\r
1394 return PnfService.getPnfs(data)
\r
1396 function (response) {
\r
1397 return response.data;
\r
1398 // * can add here changes on the data that are needed to the view ( filter, ect..)
\r
1400 function (error) {
\r
1401 console.error(error);
\r
1407 function _setCr(data) { // data is the $scope.service.instance object
\r
1408 return CrService.getCr(data)
\r
1410 function (response) {
\r
1411 return response.data.results;
\r
1412 // * can add here changes on the data that are needed to the view ( filter, ect..)
\r
1414 function (error) {
\r
1415 console.error(error);
\r
1422 Callbaks functions
\r
1425 var updateProvStatusVnfCallbackFunction = function (response) {
\r
1426 $scope.callbackResults = "";
\r
1427 var color = FIELD.ID.COLOR_NONE;
\r
1428 $scope.callbackStyle = {
\r
1429 "background-color": color
\r
1431 $scope.reloadRoute();
\r
1433 * This 1/2 delay was only added to visually highlight the status
\r
1434 * change. Probably not needed in the real application code.
\r
1436 $timeout(function () {
\r
1437 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1438 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1439 if (response.isSuccessful) {
\r
1440 color = FIELD.ID.COLOR_8F8;
\r
1443 color = FIELD.ID.COLOR_F88;
\r
1445 $scope.callbackStyle = {
\r
1446 "background-color": color
\r
1452 var createVnfCallbackFunction = function (response) {
\r
1453 $scope.callbackResults = "";
\r
1454 var color = FIELD.ID.COLOR_NONE;
\r
1455 $scope.callbackStyle = {
\r
1456 "background-color": color
\r
1460 * This 1/2 delay was only added to visually highlight the status
\r
1461 * change. Probably not needed in the real application code.
\r
1463 $timeout(function () {
\r
1464 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1465 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1466 if (response.isSuccessful) {
\r
1467 color = FIELD.ID.COLOR_8F8;
\r
1468 $scope.reloadRoute();
\r
1470 color = FIELD.ID.COLOR_F88;
\r
1472 $scope.callbackStyle = {
\r
1473 "background-color": color
\r
1480 var deleteOrResumeCallback = function (response) {
\r
1481 $scope.callbackResults = "";
\r
1482 var color = FIELD.ID.COLOR_NONE;
\r
1483 $scope.callbackStyle = {
\r
1484 "background-color": color
\r
1488 * This 1/2 delay was only added to visually highlight the status
\r
1489 * change. Probably not needed in the real application code.
\r
1491 $timeout(function () {
\r
1492 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1493 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1494 if (response.isSuccessful) {
\r
1495 color = FIELD.ID.COLOR_8F8;
\r
1496 $scope.reloadRoute();
\r
1498 color = FIELD.ID.COLOR_F88;
\r
1500 $scope.callbackStyle = {
\r
1501 "background-color": color
\r
1507 var createVfModuleCallbackFunction = function (response) {
\r
1508 $scope.callbackResults = "";
\r
1509 var color = FIELD.ID.COLOR_NONE;
\r
1510 $scope.callbackStyle = {
\r
1511 "background-color": color
\r
1515 * This 1/2 delay was only added to visually highlight the status
\r
1516 * change. Probably not needed in the real application code.
\r
1518 $timeout(function () {
\r
1519 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1520 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1521 if (response.isSuccessful) {
\r
1522 color = FIELD.ID.COLOR_8F8;
\r
1523 $scope.reloadRoute();
\r
1525 color = FIELD.ID.COLOR_F88;
\r
1527 $scope.callbackStyle = {
\r
1528 "background-color": color
\r
1534 var deleteServiceInstanceCallbackFunction = function (response) {
\r
1535 $scope.callbackResults = "";
\r
1536 var color = FIELD.ID.COLOR_NONE;
\r
1537 $scope.callbackStyle = {
\r
1538 "background-color": color
\r
1542 * This 1/2 delay was only added to visually highlight the status
\r
1543 * change. Probably not needed in the real application code.
\r
1545 $timeout(function () {
\r
1546 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1547 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1548 if (response.isSuccessful) {
\r
1549 color = FIELD.ID.COLOR_8F8;
\r
1550 $location.path(COMPONENT.SERVICEMODELS_MODELS_SERVICES_PATH);
\r
1552 color = FIELD.ID.COLOR_F88;
\r
1554 $scope.callbackStyle = {
\r
1555 "background-color": color
\r
1561 var createVolumeGroupCallbackFunction = function (response) {
\r
1562 $scope.callbackResults = "";
\r
1563 var color = FIELD.ID.COLOR_NONE;
\r
1564 $scope.callbackStyle = {
\r
1565 "background-color": color
\r
1569 * This 1/2 delay was only added to visually highlight the status
\r
1570 * change. Probably not needed in the real application code.
\r
1572 $timeout(function () {
\r
1573 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1574 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1575 if (response.isSuccessful) {
\r
1576 color = FIELD.ID.COLOR_8F8;
\r
1577 $scope.reloadRoute();
\r
1579 color = FIELD.ID.COLOR_F88;
\r
1581 $scope.callbackStyle = {
\r
1582 "background-color": color
\r