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) {
\r
32 $scope.popup = new Object();
\r
33 $scope.defaultBaseUrl = "";
\r
34 $scope.responseTimeoutMsec = 60000;
\r
35 $scope.properties = UtilityService.getProperties();
\r
36 $scope.init = function() {
\r
39 * These 2 statements should be included in non-test code.
\r
41 // takes a default value, retrieves the prop value from the file system and sets it
\r
42 var msecs = PropertyService.retrieveMsoMaxPollingIntervalMsec();
\r
43 PropertyService.setMsoMaxPollingIntervalMsec(msecs);
\r
45 // takes a default value, retrieves the prop value from the file system and sets it
\r
46 var polls = PropertyService.retrieveMsoMaxPolls();
\r
47 PropertyService.setMsoMaxPolls(polls);
\r
49 PropertyService.setServerResponseTimeoutMsec(10000);
\r
52 * Common parameters that shows an example of how the view edit screen
\r
53 * is expected to pass some common service instance values to the
\r
57 // DataService.setSubscriberName("Mobility");
\r
58 // DataService.setGlobalCustomerId("CUSTID12345")
\r
59 // DataService.setServiceType("Mobility Type 1");
\r
60 // DataService.setServiceInstanceName("Example Service Instance Name");
\r
61 // DataService.setServiceName("Mobility Service 1");
\r
62 // DataService.setServiceInstanceId("mmsc-test-service-instance");
\r
63 // DataService.setServiceUuid("XXXX-YYYY-ZZZZ");
\r
64 // DataService.setUserServiceInstanceName("USER_SERVICE_INSTANCE_NAME");
\r
67 //PropertyService.setMsoBaseUrl("testmso");
\r
69 $scope.convertModel = function(asdcModel) {
\r
70 if (!asdcModel) return undefined;
\r
71 var convertedAsdcModel = UtilityService.convertModel(asdcModel);
\r
72 return convertedAsdcModel;
\r
76 "model": vidService.getModel(),
\r
77 "convertedModel": $scope.convertModel(vidService.getModel()),
\r
78 "instance": vidService.getInstance()
\r
81 $scope.returnVfModules = function (vnfInstance) {
\r
83 var svcModel = $scope.service.convertedModel;
\r
84 //var vnfModelInvariantUuid = vnfInstance[FIELD.ID.MODEL_INVAR_ID];
\r
85 var vnfModelVersionId = vnfInstance[FIELD.ID.MODEL_VERSION_ID]; // model uuid
\r
86 var vnfModelCustomizationUuid = vnfInstance[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
88 var vnfModel = null;
\r
90 if ( (!($scope.isObjectEmpty(svcModel))) && ( !($scope.isObjectEmpty(svcModel.vnfs) ) ) ) {
\r
91 if ( (svcModel.isNewFlow) && (vnfModelCustomizationUuid != null ) ) {
\r
92 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
93 if ( !($scope.isObjectEmpty(vnfModel.vfModules) ) ) {
\r
94 //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.vfModules, null, 4));
\r
95 return (vnfModel.vfModules);
\r
100 if ( vnfModelVersionId != null ) {
\r
101 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
102 if ( !($scope.isObjectEmpty(vnfModel.vfModules) ) ) {
\r
103 //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.vfModules, null, 4));
\r
104 return (vnfModel.vfModules);
\r
112 $scope.hasVfModules = function (vnfInstance) {
\r
113 if ($scope.returnVfModules(vnfInstance) != null ){
\r
118 $scope.returnVolumeGroups = function (vnfInstance) {
\r
120 var svcModel = $scope.service.convertedModel;
\r
122 //var vnfModelInvariantUuid = vnfInstance[FIELD.ID.MODEL_INVAR_ID];
\r
123 var vnfModelVersionId = vnfInstance[FIELD.ID.MODEL_VERSION_ID];
\r
124 var vnfModelCustomizationUuid = vnfInstance[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
126 var vnfModel = null;
\r
128 if ( (!($scope.isObjectEmpty(svcModel))) && ( !($scope.isObjectEmpty(svcModel.vnfs) ) ) ) {
\r
129 if ( (svcModel.isNewFlow) && (vnfModelCustomizationUuid != null ) ) {
\r
130 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
131 if ( !($scope.isObjectEmpty(vnfModel.volumeGroups) ) ) {
\r
132 //console.log ("vnfModel.volumeGroups: "); console.log (JSON.stringify(vnfModel.volumeGroups, null, 4));
\r
133 return (vnfModel.volumeGroups);
\r
138 if ( vnfModelVersionId != null ) {
\r
139 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
140 if ( !($scope.isObjectEmpty(vnfModel.volumeGroups) ) ) {
\r
141 //console.log ("vnfModel.vfModules: "); console.log (JSON.stringify(vnfModel.volumeGroups, null, 4));
\r
142 return (vnfModel.volumeGroups);
\r
150 $scope.hasVolumeGroups = function (vnfInstance) {
\r
151 if ($scope.returnVolumeGroups(vnfInstance) != null ){
\r
156 $scope.deleteNetwork = function(serviceObject, network) {
\r
158 console.log("Removing Network " + network.name);
\r
160 //Send delete network request to MSO
\r
162 //var networks = this.service.instance.networks;
\r
164 //networks.splice(networks.indexOf(network), 1);
\r
166 //Retrieve updated data from A&AI
\r
167 var serviceInstance = serviceObject.object;
\r
168 var svcModel = $scope.service.convertedModel;
\r
170 DataService.setInventoryItem(network.object);
\r
171 // set model default and override later if found
\r
172 DataService.setModelInfo(COMPONENT.NETWORK, {});
\r
174 if ( network.object != null ) {
\r
176 //var netModelInvariantUuid = network.object[FIELD.ID.MODEL_INVAR_ID];
\r
177 var netModelVersionId = network.object[FIELD.ID.MODEL_VERSION_ID]; // model uuid
\r
178 var netModelCustomizationUuid = network.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
180 if ( (!($scope.isObjectEmpty(svcModel))) && ( !($scope.isObjectEmpty(svcModel.networks) ) ) ) {
\r
181 if ( (svcModel.isNewFlow) && (UtilityService.hasContents(netModelCustomizationUuid) ) ) {
\r
182 netModel = svcModel.networks[netModelCustomizationUuid];
\r
186 if ( UtilityService.hasContents(netModelVersionId) ) {
\r
187 netModel = svcModel.networks[netModelVersionId];
\r
193 if (!($scope.isObjectEmpty(netModel) ) ) {
\r
194 DataService.setModelInfo(COMPONENT.NETWORK, {
\r
195 "modelInvariantId": netModel.invariantUuid,
\r
196 "modelVersion": netModel.version,
\r
197 "modelNameVersionId": netModel.uuid,
\r
198 "modelCustomizationName": netModel.modelCustomizationName,
\r
199 "customizationUuid": netModel.customizationUuid,
\r
200 "modelName": netModel.name,
\r
205 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
206 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
207 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
209 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
210 DataService.setServiceInstanceName($scope.service.instance.name);
\r
211 DataService.setServiceName($scope.service.model.service.name);
\r
212 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
213 DataService.setNetworkInstanceId(network.object[FIELD.ID.NETWORK_ID]);
\r
215 $scope.$broadcast(COMPONENT.DELETE_COMPONENT, {
\r
216 componentId : COMPONENT.NETWORK,
\r
217 callbackFunction : deleteCallbackFunction
\r
221 $scope.deleteService = function(serviceObject) {
\r
223 var serviceInstance = serviceObject.object;
\r
225 console.log("Removing Service " + $scope.service.instance.name);
\r
227 DataService.setALaCarte (true);
\r
228 DataService.setInventoryItem(serviceInstance);
\r
230 DataService.setModelInfo(COMPONENT.SERVICE, {
\r
231 "modelInvariantId": serviceInstance[FIELD.ID.MODEL_INVAR_ID],
\r
232 "modelVersion": $scope.service.model.service.version,
\r
233 "modelNameVersionId": $scope.service.model.service.uuid,
\r
234 "modelName": $scope.service.model.service.name,
\r
238 DataService.setSubscriberName(serviceObject[FIELD.ID.SUBSCRIBER_NAME]);
\r
239 DataService.setServiceType(serviceObject[FIELD.ID.SERVICE_TYPE]);
\r
240 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
242 DataService.setGlobalCustomerId(serviceObject[COMPONENT.GLOBAL_CUSTOMER_ID]);
\r
243 DataService.setServiceInstanceName($scope.service.instance.name);
\r
245 DataService.setServiceName($scope.service.model.service.name);
\r
247 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
249 $scope.$broadcast(COMPONENT.DELETE_COMPONENT, {
\r
250 componentId : COMPONENT.SERVICE,
\r
251 callbackFunction : deleteServiceInstanceCallbackFunction
\r
256 $scope.deleteVfModule = function(serviceObject, vfModule, vnf) {
\r
258 console.log("Removing VF-Module " + vfModule.name);
\r
260 var serviceInstance = serviceObject.object;
\r
262 DataService.setInventoryItem(vfModule.object);
\r
264 var svcModel = $scope.service.convertedModel;
\r
266 //var vnfModelInvariantUuid = vnf.object[FIELD.ID.MODEL_INVAR_ID];
\r
267 var vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
268 var vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];;
\r
269 var vfModuleInstanceID = vfModule.object[FIELD.ID.VF_MODULE_ID];
\r
270 if (vfModuleInstanceID == null) {
\r
271 vfModuleInstanceID = "";
\r
274 var vnfModel = null;
\r
275 var vfModuleModel = null;
\r
277 DataService.setModelInfo(COMPONENT.VF_MODULE, {
\r
278 "modelInvariantId": "",
\r
279 "modelVersion": "",
\r
280 "modelNameVersionId": "",
\r
281 "modelCustomizationName": "",
\r
282 "customizationUuid": "",
\r
287 if ( (!($scope.isObjectEmpty(svcModel))) && ( !($scope.isObjectEmpty(svcModel.vnfs) ) ) ) {
\r
288 if ( (svcModel.isNewFlow) && (vnfModelCustomizationUuid != null ) ) {
\r
289 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
291 var vfModuleCustomizationUuid = vfModule.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
292 if ( !($scope.isObjectEmpty(vnfModel.vfModules) ) && UtilityService.hasContents(vfModuleCustomizationUuid) ) {
\r
294 vfModuleModel = vnfModel.vfModules[vfModuleCustomizationUuid];
\r
300 if (vnfModelVersionId != null ) {
\r
301 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
303 //var vfModuleInvariantUuid = vfModule.object[FIELD.ID.MODEL_INVAR_ID];
\r
304 var vfModuleModelVersionId = vfModule.object[FIELD.ID.MODEL_VERSION_ID];
\r
305 if ( (!($scope.isObjectEmpty(vnfModel))) && (!($scope.isObjectEmpty(vnfModel.vfModules))) &&
\r
306 UtilityService.hasContents(vfModuleModelVersionId) ) {
\r
307 vfModuleModel = vnfModel.vfModules[vfModuleModelVersionId];
\r
310 if ( !($scope.isObjectEmpty(vfModuleModel)) ) {
\r
311 DataService.setModelInfo(COMPONENT.VF_MODULE, {
\r
312 "modelInvariantId": vfModuleModel.invariantUuid,
\r
313 "modelVersion": vfModuleModel.version,
\r
314 "modelNameVersionId": vfModuleModel.uuid,
\r
315 "modelCustomizationName": vfModuleModel.modelCustomizationName,
\r
316 "customizationUuid": vfModuleModel.customizationUuid,
\r
317 "modelName": vfModuleModel.name,
\r
323 DataService.setVnfInstanceId(vnf.object[FIELD.ID.VNF_ID]);
\r
324 DataService.setVfModuleInstanceId(vfModuleInstanceID);
\r
326 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
327 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
328 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
330 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
331 DataService.setServiceInstanceName($scope.service.instance.name);
\r
333 DataService.setServiceName($scope.service.model.service.name);
\r
335 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
337 $scope.$broadcast(COMPONENT.DELETE_COMPONENT, {
\r
338 componentId : COMPONENT.VF_MODULE,
\r
339 callbackFunction : deleteCallbackFunction
\r
346 $scope.deleteVnf = function(serviceObject, vnf) {
\r
348 console.log("Removing VNF " + vnf.name);
\r
350 var serviceInstance = serviceObject.object;
\r
351 var svcModel = $scope.service.convertedModel;
\r
352 DataService.setInventoryItem(vnf.object);
\r
354 /*var vnftype = vnf.object['vnf-type'];
\r
355 if (vnftype == null)
\r
359 var n = vnftype.search("/");
\r
361 vnftype = vnftype.substring(n+1);
\r
364 var svcModel = $scope.service.convertedModel;
\r
365 var vnfModelInvariantUuid = null;
\r
366 var vnfModelVersion = null;
\r
367 var vnfModelCustomizationUuid = null;
\r
368 var vnfModel = null;
\r
370 vnfModelInvariantUuid = vnf.object[FIELD.ID.MODEL_INVAR_ID];
\r
371 vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
372 vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
374 DataService.setModelInfo(COMPONENT.VNF, {
\r
375 "modelInvariantId": vnfModelInvariantUuid,
\r
376 "modelVersion": "",
\r
377 "modelNameVersionId": vnfModelVersionId,
\r
378 "modelCustomizationName": "",
\r
379 "customizationUuid": vnfModelCustomizationUuid,
\r
384 if ( (!($scope.isObjectEmpty(svcModel))) && ( !($scope.isObjectEmpty(svcModel.vnfs) ) ) ) {
\r
385 if ( (svcModel.isNewFlow) && (vnfModelCustomizationUuid != null ) ) {
\r
386 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
389 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
391 //console.log ( "vnf models: "); console.log ( JSON.stringify ($scope.service.convertedModel.vnfs, null, 4) );
\r
392 if ( !($scope.isObjectEmpty(vnfModel) ) ) {
\r
394 DataService.setModelInfo(COMPONENT.VNF, {
\r
395 "modelInvariantId": vnfModel.invariantUuid,
\r
396 "modelVersion": vnfModel.version,
\r
397 "modelNameVersionId": vnfModel.uuid,
\r
398 "modelCustomizationName": vnfModel.modelCustomizationName,
\r
399 "customizationUuid": vnfModel.customizationUuid,
\r
400 "modelName": vnfModel.name,
\r
406 DataService.setVnfInstanceId(vnf.object[FIELD.ID.VNF_ID]);
\r
408 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
409 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
410 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
412 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
413 DataService.setServiceInstanceName($scope.service.instance.name);
\r
415 DataService.setServiceName($scope.service.model.service.name);
\r
417 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
419 $scope.$broadcast(COMPONENT.DELETE_COMPONENT, {
\r
420 componentId : COMPONENT.VNF,
\r
421 callbackFunction : deleteCallbackFunction
\r
428 $scope.deleteVolumeGroup = function(serviceObject, vnf, vfModule, volumeGroup) {
\r
430 console.log("Removing Volume Group " + volumeGroup.name);
\r
431 var haveModel = false;
\r
432 var svcModel = $scope.service.convertedModel;
\r
434 var vnfModelInvariantUuid = null;
\r
435 var vnfModelVersion = null;
\r
436 var vnfModelCustomizationUuid = null;
\r
437 var vnfModel = 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.VOLUME_GROUP, {
\r
444 "modelInvariantId": "",
\r
445 "modelVersion": "",
\r
446 "modelNameVersionId": "",
\r
447 "modelCustomizationName": "",
\r
448 "customizationUuid": "",
\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
463 // volume groups don't have model-invariant-id/version in a&ai.
\r
464 // Their model-invariant-id/version is the one for the associated vfModule
\r
466 var vfModuleInvariantUuid = vfModule.object[FIELD.ID.MODEL_INVAR_ID];
\r
467 var vfModuleModelVersionId = vfModule.object[FIELD.ID.MODEL_VERSION_ID];
\r
468 var vfModuleCustomizationUuid = vfModule.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
469 var volGroupModel = null;
\r
471 if ( !($scope.isObjectEmpty(vnfModel.volumeGroups) ) ) {
\r
472 if ( ( !($scope.isObjectEmpty(vnfModel) ) ) && ( !($scope.isObjectEmpty(vnfModel.volumeGroups) ) ) ) {
\r
473 if ( (svcModel.isNewFlow) && (UtilityService.hasContents(vfModuleCustomizationUuid) ) ){
\r
474 volGroupModel = vnfModel.volumeGroups[vfModuleCustomizationUuid];
\r
477 volGroupModel = vnfModel.volumeGroups[vfModuleModelVersionId];
\r
479 if ( !($scope.isObjectEmpty(volGroupModel) ) ) {
\r
480 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
\r
481 "modelInvariantId": volGroupModel.invariantUuid,
\r
482 "modelVersion": volGroupModel.version,
\r
483 "modelNameVersionId": volGroupModel.uuid,
\r
484 "modelCustomizationName": volGroupModel.modelCustomizationName,
\r
485 "customizationUuid": volGroupModel.customizationUuid,
\r
486 "modelName": volGroupModel.name,
\r
494 var serviceInstance = serviceObject.object;
\r
496 DataService.setInventoryItem(volumeGroup.object);
\r
498 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
499 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
500 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
502 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
503 DataService.setServiceInstanceName($scope.service.instance.name);
\r
505 DataService.setServiceName($scope.service.model.service.name);
\r
507 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
508 DataService.setVnfInstanceId(vnf.nodeId);
\r
509 DataService.setVolumeGroupInstanceId(volumeGroup.nodeId);
\r
511 $scope.$broadcast(COMPONENT.DELETE_COMPONENT, {
\r
512 componentId : COMPONENT.VOLUME_GROUP,
\r
516 $scope.deleteVnfVolumeGroup = function(serviceObject, vnf, volumeGroup) {
\r
518 console.log("Removing Volume Group " + volumeGroup.name);
\r
519 var serviceInstance = serviceObject.object;
\r
521 DataService.setInventoryItem(volumeGroup.object);
\r
523 var svcModel = $scope.service.convertedModel;
\r
525 var vnfModelInvariantUuid = vnf.object[FIELD.ID.MODEL_INVAR_ID];
\r
526 var vnfModelVersionId = vnf.object[FIELD.ID.MODEL_VERSION_ID];
\r
527 var vnfModelCustomizationUuid = vnf.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
529 var volGroupModelInvariantUuid = volumeGroup.object[FIELD.ID.MODEL_INVAR_ID];
\r
530 var volGroupModelVersionId = volumeGroup.object[FIELD.ID.MODEL_VERSION_ID];
\r
531 var volGroupModelCustomizationUuid = volumeGroup.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
533 var vnfModel = null;
\r
534 var volGroupModel = null;
\r
536 // send an empty model by default since model is not required for deletes
\r
537 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {});
\r
539 if ( svcModel.isNewFlow ) {
\r
540 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
541 if ( UtilityService.hasContents (volGroupModelCustomizationUuid) ) {
\r
542 volGroupModel = vnfModel.volumeGroups[volGroupModelCustomizationUuid];
\r
547 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
548 if ( UtilityService.hasContents (volGroupModelVersionId) ) {
\r
549 volGroupModel = vnfModel.volumeGroups[volGroupModelVersionId];
\r
552 if ( !($scope.isObjectEmpty(volGroupModel) ) ) {
\r
553 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
\r
554 "modelInvariantId": volGroupModel.invariantUuid,
\r
555 "modelVersion": volGroupModel.version,
\r
556 "modelNameVersionId": volGroupModel.uuid,
\r
557 "modelName": volGroupModel.name,
\r
558 "modelCustomizationName": volGroupModel.modelCustomizationName,
\r
559 "customizationUuid": volGroupModel.customizationUuid,
\r
564 DataService.setVnfInstanceId(vnf.object[FIELD.ID.VNF_ID]);
\r
566 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
567 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
568 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
570 DataService.setGlobalCustomerId(serviceObject[FIELD.ID.GLOBAL_CUST_ID]);
\r
571 DataService.setServiceInstanceName($scope.service.instance.name);
\r
573 DataService.setServiceName($scope.service.model.service.name);
\r
575 DataService.setServiceUuid($scope.service.model.service.uuid);
\r
576 DataService.setVnfInstanceId(vnf.nodeId);
\r
577 DataService.setVolumeGroupInstanceId(volumeGroup.nodeId);
\r
579 $scope.$broadcast(COMPONENT.DELETE_COMPONENT, {
\r
580 componentId : COMPONENT.VOLUME_GROUP,
\r
581 callbackFunction : deleteCallbackFunction
\r
585 $scope.describeNetwork = function(serviceObject, networkObject) {
\r
586 var serviceInstance = serviceObject.object;
\r
587 var network = networkObject.object;
\r
588 //console.log ("networkObject="); console.log (JSON.stringify(networkObject, null, 4));
\r
590 DataService.setResCustomizationUuid(" ");
\r
592 var svcModel = $scope.service.convertedModel;
\r
593 var netModel = null;
\r
595 if ( !($scope.isObjectEmpty(network) ) ) {
\r
597 var netModelInvariantUuid = network[FIELD.ID.MODEL_INVAR_ID];
\r
598 var netModelVersionId = network[FIELD.ID.MODEL_VERSION_ID];
\r
599 var netModelCustomizationUuid = network[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
601 if ( UtilityService.hasContents (netModelCustomizationUuid) ) {
\r
602 // set it to what came from a&ai
\r
603 DataService.setResCustomizationUuid(netModelCustomizationUuid);
\r
606 if ( (!($scope.isObjectEmpty(svcModel))) && (!($scope.isObjectEmpty(svcModel.networks))) ) {
\r
607 if ( svcModel.isNewFlow ) {
\r
608 netModel = svcModel.networks[netModelCustomizationUuid];
\r
611 netModel = svcModel.networks[netModelVersionId];
\r
614 * The details pop-up should use a&ai info
\r
615 * if ( !($scope.isObjectEmpty(netModel) ) ) {
\r
616 if (UtilityService.hasContents(netModel.customizationUuid)) {
\r
617 DataService.setResCustomizationUuid(netModel.customizationUuid);
\r
623 DataService.setNetworkInstanceId(network[FIELD.ID.NETWORK_ID]);
\r
624 DataService.setInventoryItem(networkObject);
\r
625 DataService.setSubscriberName(serviceObject.subscriberName);
\r
626 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
627 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
629 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
630 componentId : COMPONENT.NETWORK
\r
634 // for service instance id - no need for this!
\r
635 $scope.describeService = function(serviceObject) {
\r
636 var serviceInstance = serviceObject.object;
\r
638 DataService.setInventoryItem(serviceInstance);
\r
639 //DataService.setModelInfo(serviceInstance['service-instance-id'], serviceInstance);
\r
641 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
642 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
643 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
645 //Display popup with additional service information
\r
646 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
647 componentId : COMPONENT.SERVICE
\r
652 $scope.describeVfModule = function(serviceObject, vfModuleObject, vnf) {
\r
653 var serviceInstance = serviceObject.object;
\r
654 var vfModule = vfModuleObject.object;
\r
656 /*var vfModuleInvariantUuid = vfModule[FIELD.ID.MODEL_INVAR_ID];
\r
657 var vfModuleModelVersionId = vfModule[FIELD.ID.MODEL_VERSION_ID];*/
\r
658 var vfModuleCustomizationUuid = vfModule[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
660 DataService.setCustomizationUuid(" ");
\r
661 if ( UtilityService.hasContents (vfModuleCustomizationUuid) ) {
\r
662 DataService.setCustomizationUuid(vfModuleCustomizationUuid);
\r
665 //Display popup with additional VF-Module information
\r
666 DataService.setVfModuleInstanceId(vfModule[FIELD.ID.VF_MODULE_ID]);
\r
667 DataService.setInventoryItem(vfModule)
\r
669 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
670 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
671 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
673 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
674 componentId : COMPONENT.VF_MODULE
\r
678 $scope.getStatusOfVnf = function(serviceObject, vnfObject) {
\r
679 var serviceInstance = serviceObject.object;
\r
680 var vnf = vnfObject.object;
\r
682 DataService.setVnfInstanceId(vnf[FIELD.ID.VNF_ID]);
\r
683 DataService.setInventoryItem(vnf);
\r
685 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
686 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
687 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
688 DataService.setServiceInstanceName(serviceInstance[FIELD.ID.SERVICE_INSTANCE_NAME]);
\r
690 $scope.$broadcast(COMPONENT.COMPONENT_STATUS, {
\r
691 componentId : COMPONENT.VNF,
\r
692 callbackFunction : updateProvStatusVnfCallbackFunction
\r
696 $scope.describeVnf = function(serviceObject, vnfObject) {
\r
697 var serviceInstance = serviceObject.object;
\r
698 var vnf = vnfObject.object;
\r
699 DataService.setResCustomizationUuid(" ");
\r
701 //var vnfInvariantUuid = vnf[FIELD.ID.MODEL_INVAR_ID];
\r
702 //var vnfVersionId = vnf[FIELD.ID.MODEL_VERSION_ID];
\r
703 var vnfCustomizationUuid = vnf[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
705 if ( UtilityService.hasContents (vnfCustomizationUuid) ) {
\r
706 DataService.setResCustomizationUuid(vnfCustomizationUuid);
\r
708 //Display popup with additional VNF information
\r
709 DataService.setVnfInstanceId(vnf[FIELD.ID.VNF_ID]);
\r
710 DataService.setInventoryItem(vnf);
\r
712 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
713 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
714 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
716 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
717 componentId : COMPONENT.VNF
\r
721 $scope.describeVolumeGroup = function(serviceObject, vnf, volumeGroupObject) {
\r
723 var serviceInstance = serviceObject.object;
\r
724 var volumeGroup = volumeGroupObject.object;
\r
726 //var volGroupInvariantUuid = volumeGroup[FIELD.ID.MODEL_INVAR_ID];
\r
727 //var volGroupVersionId = volumeGroup[FIELD.ID.MODEL_VERSION_ID];
\r
728 var volGroupCustomizationUuid = volumeGroup[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
730 DataService.setCustomizationUuid(" ");
\r
731 if ( UtilityService.hasContents(volGroupCustomizationUuid) ) {
\r
732 DataService.setCustomizationUuid(volGroupCustomizationUuid);
\r
734 DataService.setVolumeGroupInstanceId(volumeGroup[FIELD.ID.VOLUME_GROUP_ID]);
\r
735 DataService.setInventoryItem(volumeGroup);
\r
737 DataService.setSubscriberName(serviceObject[COMPONENT.SUBSCRIBER_NAME]);
\r
738 DataService.setServiceType(serviceObject[COMPONENT.SERVICE_TYPE]);
\r
739 DataService.setServiceInstanceId(serviceInstance[FIELD.ID.SERVICE_INSTANCE_ID]);
\r
742 $scope.$broadcast(COMPONENT.SHOW_COMPONENT_DETAILS, {
\r
743 componentId : COMPONENT.VOLUME_GROUP
\r
747 $scope.addNetworkInstance = function(netModel, existingVnfs) {
\r
749 // For networks we assume that we always follow the new flow
\r
750 console.log("Adding network to service instance" + this.service.instance.name);
\r
751 if ( VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED && (UtilityService.hasContents(existingVnfs)) && (existingVnfs.length > 0) ) {
\r
752 var msg = VnfService.isVnfListStatusValid (existingVnfs);
\r
759 DataService.setSubscriberName($scope.service.instance.subscriberName);
\r
760 DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
\r
761 DataService.setServiceType($scope.service.instance.serviceType);
\r
762 DataService.setServiceInstanceName($scope.service.instance.name);
\r
763 DataService.setServiceInstanceId($scope.service.instance.id);
\r
764 DataService.setServiceName($scope.service.model.service.name);
\r
766 DataService.setModelInfo(COMPONENT.NETWORK, {
\r
767 "modelType": "network",
\r
768 "modelInvariantId": netModel.invariantUuid,
\r
769 "modelVersion": netModel.version,
\r
770 "modelNameVersionId": netModel.uuid,
\r
771 "modelName": netModel.name,
\r
772 "modelCustomizationName": netModel.modelCustomizationName,
\r
773 "customizationUuid": netModel.customizationUuid,
\r
775 "displayInputs": netModel.displayInputs
\r
778 DataService.setModelInfo(COMPONENT.SERVICE, {
\r
779 "modelInvariantId": $scope.service.model.service.invariantUuid,
\r
780 "modelVersion": $scope.service.model.service.version,
\r
781 "modelNameVersionId": $scope.service.model.service.uuid,
\r
782 "modelName": $scope.service.model.service.name,
\r
786 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {
\r
787 componentId : COMPONENT.NETWORK,
\r
788 callbackFunction : createVnfCallbackFunction
\r
792 $scope.addVnfInstance = function(vnf, existingVnfs) {
\r
794 if ( VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED && (UtilityService.hasContents(existingVnfs)) && (existingVnfs.length > 0) ) {
\r
795 var msg = VnfService.isVnfListStatusValid (existingVnfs);
\r
801 DataService.setSubscriberName($scope.service.instance.subscriberName);
\r
802 DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
\r
803 DataService.setServiceType($scope.service.instance.serviceType);
\r
804 DataService.setServiceInstanceName($scope.service.instance.name);
\r
805 DataService.setServiceInstanceId($scope.service.instance.id);
\r
806 DataService.setServiceName($scope.service.model.service.name);
\r
808 console.log ( "existingVnfs: " ); console.log (JSON.stringify ( existingVnfs, null, 4));
\r
811 var vnf_function = "";
\r
814 if (UtilityService.hasContents (vnf.nfType) ) {
\r
815 vnf_type = vnf.nfType;
\r
817 if (UtilityService.hasContents (vnf.nfRole) ) {
\r
818 vnf_role = vnf.nfRole;
\r
820 if (UtilityService.hasContents (vnf.nfFunction) ) {
\r
821 vnf_function = vnf.nfFunction;
\r
823 if (UtilityService.hasContents (vnf.nfCode) ) {
\r
824 vnf_code = vnf.nfCode;
\r
826 DataService.setModelInfo(COMPONENT.VNF, {
\r
827 "modelType": "vnf",
\r
828 "modelInvariantId": vnf.invariantUuid,
\r
829 "modelVersion": vnf.version,
\r
830 "modelNameVersionId": vnf.uuid,
\r
831 "modelName": vnf.name,
\r
832 "modelCustomizationName": vnf.modelCustomizationName,
\r
833 "customizationUuid": vnf.customizationUuid,
\r
835 "displayInputs": vnf.displayInputs,
\r
836 "vnfType": vnf_type,
\r
837 "vnfRole": vnf_role,
\r
838 "vnfFunction": vnf_function,
\r
839 "vnfCode": vnf_code
\r
842 DataService.setModelInstanceName($scope.service.model.service.name);
\r
844 DataService.setModelInfo(COMPONENT.SERVICE, {
\r
845 "modelInvariantId": $scope.service.model.service.invariantUuid,
\r
846 "modelVersion": $scope.service.model.service.version,
\r
847 "modelNameVersionId": $scope.service.model.service.uuid,
\r
848 "modelName": $scope.service.model.service.name,
\r
852 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {
\r
853 componentId : COMPONENT.VNF,
\r
854 callbackFunction : createVnfCallbackFunction
\r
858 $scope.addVfModuleInstance = function(vnfInstance, vfModuleModel) {
\r
860 if ( VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED ) {
\r
861 var msg = VnfService.isVnfStatusValid (vnfInstance);
\r
868 var svcModel = $scope.service.convertedModel;
\r
869 DataService.setSubscriberName($scope.service.instance.subscriberName);
\r
870 DataService.setGlobalCustomerId($scope.service.instance.globalCustomerId);
\r
871 DataService.setServiceType($scope.service.instance.serviceType);
\r
872 DataService.setServiceInstanceName($scope.service.instance.name);
\r
873 DataService.setServiceInstanceId($scope.service.instance.id);
\r
874 DataService.setServiceName($scope.service.model.service.name);
\r
876 var vnfModelInvariantUuid = vnfInstance.object[FIELD.ID.MODEL_INVAR_ID];
\r
877 var vnfModelVersionId = vnfInstance.object[FIELD.ID.MODEL_VERSION_ID];
\r
878 var vnfModelCustomizationUuid = vnfInstance.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
879 var vnfModel = null;
\r
880 if ( svcModel.isNewFlow ) {
\r
881 vnfModel = svcModel.vnfs[vnfModelCustomizationUuid];
\r
884 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
887 var availableVolumeGroupList = [];
\r
888 angular.forEach(vnfInstance[FIELD.ID.AVAILABLEVOLUMEGROUPS], function(volumeGroupInstance, key) {
\r
889 availableVolumeGroupList.push({"instance": volumeGroupInstance});
\r
892 if (vfModuleModel.volumeGroupAllowed) {
\r
893 DataService.setAvailableVolumeGroupList(availableVolumeGroupList);
\r
896 DataService.setModelInfo(COMPONENT.SERVICE, {
\r
897 "modelInvariantId": $scope.service.model.service.invariantUuid,
\r
898 "modelVersion": $scope.service.model.service.version,
\r
899 "modelNameVersionId": $scope.service.model.service.uuid,
\r
900 "modelName": $scope.service.model.service.name,
\r
904 DataService.setVnfInstanceId(vnfInstance.object[FIELD.ID.VNF_ID]);
\r
906 DataService.setModelInfo(COMPONENT.VNF, {
\r
907 "modelInvariantId": vnfModel.invariantUuid,
\r
908 "modelVersion": vnfModel.version,
\r
909 "modelNameVersionId": vnfModel.uuid,
\r
910 "modelName": vnfModel.name,
\r
911 "modelCustomizationName": vnfModel.modelCustomizationName,
\r
912 "customizationUuid": vnfModel.customizationUuid,
\r
916 DataService.setModelInfo(COMPONENT.VF_MODULE, {
\r
917 "modelInvariantId": vfModuleModel.invariantUuid,
\r
918 "modelVersion": vfModuleModel.version,
\r
919 "modelNameVersionId": vfModuleModel.uuid,
\r
920 "customizationUuid": vfModuleModel.customizationUuid,
\r
921 "modelCustomizationName": vfModuleModel.modelCustomizationName,
\r
922 "modelName": vfModuleModel.name,
\r
926 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {
\r
927 componentId : COMPONENT.VF_MODULE,
\r
928 callbackFunction : createVfModuleCallbackFunction
\r
933 $scope.addVolumeGroupInstance = function(vnfInstance, volumeGroupModel) {
\r
934 if ( VIDCONFIGURATION.VNF_STATUS_CHECK_ENABLED ) {
\r
935 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 DataService.setModelInfo(COMPONENT.SERVICE, {
\r
950 "modelInvariantId": $scope.service.model.service.invariantUuid,
\r
951 "modelVersion": $scope.service.model.service.version,
\r
952 "modelNameVersionId": $scope.service.model.service.uuid,
\r
953 "modelName": $scope.service.model.service.name,
\r
957 DataService.setVnfInstanceId(vnfInstance.object[FIELD.ID.VNF_ID]);
\r
959 var vnfModelInvariantUuid = vnfInstance.object[FIELD.ID.MODEL_INVAR_ID];
\r
960 var vnfModelVersionId = vnfInstance.object[FIELD.ID.MODEL_VERSION_ID];
\r
961 var vnfCustomizationUuid = vnfInstance.object[FIELD.ID.MODEL_CUSTOMIZATION_ID];
\r
962 var vnfModel = null;
\r
964 if ( svcModel.isNewFlow ) {
\r
965 vnfModel = svcModel.vnfs[vnfCustomizationUuid];
\r
968 vnfModel = svcModel.vnfs[vnfModelVersionId];
\r
971 DataService.setModelInfo(COMPONENT.VNF, {
\r
972 "modelInvariantId": vnfModel.invariantUuid,
\r
973 "modelVersion": vnfModel.version,
\r
974 "modelNameVersionId": vnfModel.uuid,
\r
975 "modelName": vnfModel.name,
\r
976 "modelCustomizationName": vnfModel.modelCustomizationName,
\r
977 "customizationUuid": vnfModel.customizationUuid,
\r
981 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, {
\r
982 "modelInvariantId": volumeGroupModel.invariantUuid,
\r
983 "modelVersion": volumeGroupModel.version,
\r
984 "modelNameVersionId": volumeGroupModel.uuid,
\r
985 "modelName": volumeGroupModel.name,
\r
986 "modelCustomizationName": volumeGroupModel.modelCustomizationName,
\r
987 "customizationUuid": volumeGroupModel.customizationUuid,
\r
991 $scope.$broadcast(COMPONENT.CREATE_COMPONENT, {
\r
992 componentId : COMPONENT.VOLUME_GROUP,
\r
993 callbackFunction : createVolumeGroupCallbackFunction
\r
997 $scope.resetProgress = function() {
\r
998 $scope.percentProgress = 0;
\r
999 $scope.progressClass = FIELD.STYLE.PROGRESS_BAR_INFO;
\r
1002 $scope.setProgress = function(percentProgress) {
\r
1003 percentProgress = parseInt(percentProgress);
\r
1004 if (percentProgress >= 100) {
\r
1005 $scope.progressClass = FIELD.STYLE.PROGRESS_BAR_SUCCESS;
\r
1008 if (percentProgress < $scope.percentProgress) {
\r
1012 $scope.percentProgress = percentProgress;
\r
1013 $scope.progressWidth = {width: percentProgress + "%"};
\r
1014 if (percentProgress >= 5) {
\r
1015 $scope.progressText = percentProgress + " %";
\r
1017 // Hidden since color combination is barely visible when progress portion is narrow.
\r
1018 $scope.progressText = "";
\r
1021 $scope.isObjectEmpty = function(o) {
\r
1023 if (UtilityService.hasContents(o)){
\r
1024 var keys = Object.keys(o);
\r
1025 len = keys.length;
\r
1037 $scope.isMacro = function() {
\r
1038 if (UtilityService.arrayContains (VIDCONFIGURATION.MACRO_SERVICES, $scope.service.model.service.invariantUuid )) {
\r
1046 $scope.reloadRoute = function() {
\r
1050 var updateProvStatusVnfCallbackFunction = function(response) {
\r
1051 $scope.callbackResults = "";
\r
1052 var color = FIELD.ID.COLOR_NONE;
\r
1053 $scope.callbackStyle = {
\r
1054 "background-color" : color
\r
1056 $scope.reloadRoute();
\r
1058 * This 1/2 delay was only added to visually highlight the status
\r
1059 * change. Probably not needed in the real application code.
\r
1061 $timeout(function() {
\r
1062 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1063 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1064 if (response.isSuccessful) {
\r
1065 color = FIELD.ID.COLOR_8F8;
\r
1068 color = FIELD.ID.COLOR_F88;
\r
1070 $scope.callbackStyle = {
\r
1071 "background-color" : color
\r
1077 var createVnfCallbackFunction = function(response) {
\r
1078 $scope.callbackResults = "";
\r
1079 var color = FIELD.ID.COLOR_NONE;
\r
1080 $scope.callbackStyle = {
\r
1081 "background-color" : color
\r
1085 * This 1/2 delay was only added to visually highlight the status
\r
1086 * change. Probably not needed in the real application code.
\r
1088 $timeout(function() {
\r
1089 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1090 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1091 if (response.isSuccessful) {
\r
1092 color = FIELD.ID.COLOR_8F8;
\r
1093 $scope.reloadRoute();
\r
1095 color = FIELD.ID.COLOR_F88;
\r
1097 $scope.callbackStyle = {
\r
1098 "background-color" : color
\r
1106 var deleteCallbackFunction = function(response) {
\r
1107 $scope.callbackResults = "";
\r
1108 var color = FIELD.ID.COLOR_NONE;
\r
1109 $scope.callbackStyle = {
\r
1110 "background-color" : color
\r
1114 * This 1/2 delay was only added to visually highlight the status
\r
1115 * change. Probably not needed in the real application code.
\r
1117 $timeout(function() {
\r
1118 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1119 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1120 if (response.isSuccessful) {
\r
1121 color = FIELD.ID.COLOR_8F8;
\r
1122 $scope.reloadRoute();
\r
1124 color = FIELD.ID.COLOR_F88;
\r
1126 $scope.callbackStyle = {
\r
1127 "background-color" : color
\r
1133 var createVfModuleCallbackFunction = function(response) {
\r
1134 $scope.callbackResults = "";
\r
1135 var color = FIELD.ID.COLOR_NONE;
\r
1136 $scope.callbackStyle = {
\r
1137 "background-color" : color
\r
1141 * This 1/2 delay was only added to visually highlight the status
\r
1142 * change. Probably not needed in the real application code.
\r
1144 $timeout(function() {
\r
1145 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1146 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1147 if (response.isSuccessful) {
\r
1148 color = FIELD.ID.COLOR_8F8;
\r
1149 $scope.reloadRoute();
\r
1151 color = FIELD.ID.COLOR_F88;
\r
1153 $scope.callbackStyle = {
\r
1154 "background-color" : color
\r
1160 var deleteServiceInstanceCallbackFunction = function(response) {
\r
1161 $scope.callbackResults = "";
\r
1162 var color = FIELD.ID.COLOR_NONE;
\r
1163 $scope.callbackStyle = {
\r
1164 "background-color" : color
\r
1168 * This 1/2 delay was only added to visually highlight the status
\r
1169 * change. Probably not needed in the real application code.
\r
1171 $timeout(function() {
\r
1172 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1173 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1174 if (response.isSuccessful) {
\r
1175 color = FIELD.ID.COLOR_8F8;
\r
1176 $location.path(COMPONENT.SERVICEMODELS_MODELS_SERVICES_PATH)
\r
1178 color = FIELD.ID.COLOR_F88;
\r
1180 $scope.callbackStyle = {
\r
1181 "background-color" : color
\r
1187 var createVolumeGroupCallbackFunction = function(response) {
\r
1188 $scope.callbackResults = "";
\r
1189 var color = FIELD.ID.COLOR_NONE;
\r
1190 $scope.callbackStyle = {
\r
1191 "background-color" : color
\r
1195 * This 1/2 delay was only added to visually highlight the status
\r
1196 * change. Probably not needed in the real application code.
\r
1198 $timeout(function() {
\r
1199 $scope.callbackResults = UtilityService.getCurrentTime()
\r
1200 + FIELD.STATUS.IS_SUCCESSFUL + response.isSuccessful;
\r
1201 if (response.isSuccessful) {
\r
1202 color = FIELD.ID.COLOR_8F8;
\r
1203 $scope.reloadRoute();
\r
1205 color = FIELD.ID.COLOR_F88;
\r
1207 $scope.callbackStyle = {
\r
1208 "background-color" : color
\r