2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
24 appDS2.controller("newChangeManagementModalController", ["$uibModalInstance", "$uibModal",'$q', "AaiService", "changeManagementService", "Upload",
25 "$log", "$scope", "_", "COMPONENT", "VIDCONFIGURATION","DataService","featureFlags", newChangeManagementModalController]);
27 function newChangeManagementModalController($uibModalInstance, $uibModal,$q, AaiService, changeManagementService, Upload, $log, $scope, _, COMPONENT, VIDCONFIGURATION, DataService, featureFlags) {
30 vm.hasScheduler = !!VIDCONFIGURATION.SCHEDULER_PORTAL_URL;
33 vm.nextStep = function(){
35 $(".modal-dialog").animate({"width":"1200px"},400,'linear');
37 vm.prevStep = function(){
39 $(".modal-dialog").animate({"width":"600px"},400,'linear');
42 vm.softwareVersionRegex = "[-a-zA-Z0-9\.]+";
46 function fetchAttUid() {
47 var defer = $q.defer();
49 defer.resolve(attuid);
51 AaiService.getLoggedInUserID(function (response) {
52 attuid = response.data;
53 defer.resolve(attuid);
62 var init = function () {
63 vm.changeManagement = {};
64 vm.changeManagement.workflowParameters = new Map();
66 loadServicesCatalog();
67 fetchAttUid().then(registerVNFNamesWatcher);
71 var loadServicesCatalog = function () {
72 changeManagementService.getAllSDCServices()
73 .then(function (response) {
74 vm.SDCServicesCatalog = response.data;
76 .catch(function (error) {
81 var registerVNFNamesWatcher = function () {
82 $scope.$watch('vm.changeManagement.vnfNames', function (newVal, oldVal) {
83 if (!oldVal || newVal && newVal.length > oldVal.length) { //JUST THE LAST ONE ADDED
84 var newVNFName = _.last(vm.changeManagement.vnfNames);
86 vm.changeManagement.vnfNames = oldVal;
87 vm.changeManagement.vnfNames.push(newVNFName);
89 if (newVNFName && newVNFName["service-instance-node"]) {
90 var availableVersions = [];
91 var services = _.filter(vm.SDCServicesCatalog.services,
92 {"invariantUUID": newVNFName["service-instance-node"][0].properties["model-invariant-id"]});
94 _.each(services, function (service) {
95 changeManagementService.getSDCService(service.uuid)
96 .then(function (response) {
97 _.each(response.data.vnfs, function (vnf) {
98 if (newVNFName["invariant-id"] === vnf.invariantUuid) {
99 availableVersions.push(extractVNFModel(vnf, response.data.service, newVNFName));
101 //for scale out screen
102 if(service.uuid === newVNFName["service-instance-node"][0].properties["model-version-id"]) {
103 newVNFName.vfModules = vnf.vfModules;
104 newVNFName.category = response.data.service.category;
105 newVNFName.groupModules = _.groupBy(newVNFName.vfModules, "customizationUuid");
107 //list vfmodules ids in AAI that belong to that vnf instance
108 var modulesAaiIds = _.filter(newVNFName.relatedTo, function(item){
109 return item["node-type"] === "vf-module";
110 }).map(function(item){
114 _.forEach(newVNFName.vfModules, function (mdl, key) {
115 mdl.scale = false; //defaults to not scale unless user changes it
116 if(mdl.properties && mdl.properties.maxCountInstances) {
118 //how many vf modules of the same customizationId belong to that vnf instance
119 mdl.currentCount = _.filter(vm.vfModules, function(item){
120 return modulesAaiIds.indexOf(item.id) > -1 && item.properties["model-customization-id"] === mdl.customizationUuid;
123 mdl.scalable = mdl.properties.maxCountInstances - mdl.currentCount > 0;
125 mdl.scalable = false;
131 var versions = _.uniqBy(availableVersions, 'modelInfo.modelVersion');
132 newVNFName.availableVersions = _.sortBy(_.uniq(versions, response.data.service, true),"modelInfo.modelVersion");
133 }).catch(function (error) {
142 var extractVNFModel = function (csarVNF, sdcService, selectionVNF) {
144 @param selectionVNF A vnf *instance* selected in "available VNF" drop-down box
145 @param csarVNF A VNF *MODEL* that has an invariantUuid same as selectionVNF (might be
146 a different version; i.e. selectionVNF.modelVersionId <> csarVNF.uuid)
147 @param sdcService The Service *MODEL* which has the related VNF `csarVNF`.
149 var versionCsarData = {
151 vnfName: csarVNF.name,
154 modelInvariantId: csarVNF.invariantUuid,
155 modelVersionId: csarVNF.uuid,
156 modelName: csarVNF.name,
157 modelVersion: csarVNF.version,
158 modelCustomizationName: csarVNF.modelCustomizationName,
159 modelCustomizationId: csarVNF.customizationUuid
161 cloudConfiguration: selectionVNF.cloudConfiguration || {},
164 suppressRollback: false,
167 relatedInstanceList: [
170 instanceId: selectionVNF["service-instance-node"]["0"].properties['service-instance-id'],
172 modelType: "service",
173 modelInvariantId: sdcService.invariantUuid,
174 modelVersionId: sdcService.uuid,
175 modelName: sdcService.name,
176 modelVersion: sdcService.version
186 return versionCsarData;
189 vm.close = function () {
190 $uibModalInstance.close();
193 vm.uploadConfigFile = function (file) {
194 var defer = $q.defer();
196 url: "change-management/uploadConfigUpdateFile",
198 transformResponse: [function (data) {
202 .then(function (configUpdateResponse) {
203 vm.getInternalWorkFlowParameter("VNF Config Update", "FILE", "Attach configuration file").value = configUpdateResponse && JSON.parse(configUpdateResponse.data).payload;
206 .catch(function (error) {
207 defer.resolve(false);
209 return defer.promise;
213 /***converting objects to scheduler format (taken from IST) - was altered for Scale out support ***/
214 function extractChangeManagementCallbackDataStr(changeManagement) {
215 console.log(changeManagement);
217 result.requestType = changeManagement.workflow;
218 var workflowType = changeManagement.workflow;
219 result.requestDetails = [];
220 _.forEach(changeManagement.vnfNames, function (vnf) {
223 var requestInfoData ={};
224 var requestParametersData ={};
225 var moduleToScale = _.find(vnf.vfModules, function(key, item){
228 if (vnf.availableVersions && vnf.availableVersions.length!=0){
231 source: vnf.availableVersions[0].requestInfo.source,
232 suppressRollback: vnf.availableVersions[0].requestInfo.suppressRollback,
233 requestorId: vnf.availableVersions[0].requestInfo.requestorId
236 if(workflowType=='Update'){
237 requestParametersData = {
238 usePreload: vnf.availableVersions[0].requestParameters.usePreload
240 }else if(workflowType=="Replace"){
241 requestParametersData = {
242 rebuildVolumeGroups: vnf.availableVersions[0].requestParameters.usePreload
244 }else if(workflowType=="VNF In Place Software Update"){
246 'existing_software_version':vm.getInternalWorkFlowParameter(workflowType, 'STRING', 'Existing software version').value,
247 'new_software_version':vm.getInternalWorkFlowParameter(workflowType, 'STRING', 'New software version').value,
248 'operations_timeout':vm.getInternalWorkFlowParameter(workflowType, 'STRING', 'Operations timeout').value
250 requestParametersData = {
251 payload: JSON.stringify(payloadObj)
253 }else if(workflowType=="VNF Config Update"){
254 requestParametersData = {
255 payload: vm.getInternalWorkFlowParameter("VNF Config Update", "FILE", "Attach configuration file").value
257 }else if(workflowType=="VNF Scale Out"){
258 if(!moduleToScale) return null;
260 if(moduleToScale.userParams) {
261 requestParametersData = {
262 userParams: moduleToScale.userParams
266 requestParametersData = {
272 $log.info('SchedulerWidgetCtrl:extractChangeManagementCallbackDataStr info:: workflowType '+ workflowType);
273 $log.info('SchedulerWidgetCtrl:extractChangeManagementCallbackDataStr info:: requestParametersData '+ requestParametersData);
275 }else if(workflowType=="VNF In Place Software Update"){
277 'existing_software_version':vm.getInternalWorkFlowParameter(workflowType, 'STRING', 'Existing software version').value,
278 'new_software_version':vm.getInternalWorkFlowParameter(workflowType, 'STRING', 'New software version').value,
279 'operations_timeout':vm.getInternalWorkFlowParameter(workflowType, 'STRING', 'Operations timeout').value
281 requestParametersData = {
282 payload: JSON.stringify(payloadObj)
284 }else if(workflowType=="VNF Config Update"){
285 requestParametersData = {
286 payload: vm.getInternalWorkFlowParameter("VNF Config Update", "FILE", "Attach configuration file").value
291 if(workflowType=="VNF Scale Out") {
294 vnfInstanceId: vnf.id,
296 modelType: 'vfModule',
297 modelInvariantId: moduleToScale.invariantUuid,
298 modelName: moduleToScale.modelCustomizationName,
299 modelVersion: moduleToScale.version,
300 modelCustomizationName: moduleToScale.modelCustomizationName,
301 modelCustomizationId: moduleToScale.customizationUuid,
302 modelVersionId: moduleToScale.uuid
304 cloudConfiguration: vnf.cloudConfiguration,
305 requestInfo: requestInfoData,
306 relatedInstanceList: [],
307 requestParameters:requestParametersData,
308 configurationParameters: JSON.parse(vm.getInternalWorkFlowParameter("VNF Scale Out", "STRING", "Configuration Parameters").value)
310 requestInfoData.instanceName = vnf.name + "_" + (moduleToScale.currentCount + 1);
314 vnfInstanceId: vnf.id,
317 modelInvariantId: vnf.properties['model-invariant-id'],
318 modelVersionId: vnf.modelVersionId,
319 modelName: vnf.properties['vnf-name'],
320 modelVersion: vnf.version,
321 modelCustomizationName: vnf.properties['model-customization-name'],
322 modelCustomizationId: vnf.properties['model-customization-id']
324 cloudConfiguration: vnf.cloudConfiguration,
325 requestInfo: requestInfoData,
326 relatedInstanceList: [],
327 requestParameters:requestParametersData
331 var serviceInstanceId = '';
332 _.forEach(vnf['service-instance-node'], function (instanceNode) {
333 if(instanceNode['node-type'] === 'service-instance'){
334 serviceInstanceId = instanceNode.properties['service-instance-id'];
338 if (vnf.availableVersions && vnf.availableVersions.length!=0){
339 _.forEach(vnf.availableVersions[0].relatedInstanceList, function (related) {
340 var rel = related.relatedInstance;
341 var relatedInstance = {
342 instanceId: serviceInstanceId,
344 modelType: rel.modelInfo.modelType,
345 modelInvariantId: rel.modelInfo.modelInvariantId,
346 modelVersionId: rel.modelInfo.modelVersionId,
347 modelName: rel.modelInfo.modelName,
348 modelVersion: rel.modelInfo.modelVersion,
349 modelCustomizationName: rel.modelInfo.modelCustomizationName,
350 modelCustomizationId: rel.modelInfo.modelCustomizationId
353 if (rel.vnfInstanceId)
354 relatedInstance.instanceId = rel.vnfInstanceId;
356 data.relatedInstanceList.push({relatedInstance: relatedInstance});
358 if(workflowType=="VNF Scale Out") {
359 //push vnf to related as well as the service instance
360 var relatedInstance = {
363 modelCustomizationId: vnf.availableVersions[0].modelInfo.modelCustomizationId,
364 modelCustomizationName: vnf.availableVersions[0].modelInfo.modelCustomizationName,
365 modelInvariantId: vnf.availableVersions[0].modelInfo.modelInvariantId,
366 modelName: vnf.availableVersions[0].modelInfo.modelName,
367 modelType: vnf.availableVersions[0].modelInfo.modelType,
368 modelVersion: vnf.availableVersions[0].modelInfo.modelVersion,
369 modelVersionId: vnf.availableVersions[0].modelInfo.modelVersionId
372 data.relatedInstanceList.push({relatedInstance: relatedInstance});
376 $log.error('SchedulerCtrl::extractChangeManagementCallbackDataStr error: ' + err);
379 result.requestDetails.push(data);
381 return JSON.stringify(result);
384 function getWorkflowParametersFromForm() {
385 let workflowParameters =
387 cloudConfiguration:{},
388 requestParameters:{userParams:[{}]}
390 workflowParameters.requestDetails.cloudConfiguration = vm.changeManagement.vnfNames[0].cloudConfiguration;
392 let parameters = vm.getRemoteWorkFlowParameters(vm.changeManagement.workflow);
393 parameters.forEach((parameter)=>{
394 let inputField = document.getElementById('so-workflow-parameter-'+parameter.soFieldName);
395 workflowParameters.requestDetails.requestParameters.userParams[0][parameter.soFieldName]=inputField.value;
398 return workflowParameters;
401 vm.openModal = function () {
402 if(vm.hasScheduler) { //scheduling supported
403 vm.scheduleWorkflow();
405 //no scheduling support
406 vm.executeWorkflow();
410 vm.scheduleWorkflow = function () {
411 $scope.widgetParameter = ""; // needed by the scheduler?
413 // properties needed by the scheduler so it knows whether to show
414 // policy or sniro related features on the scheduler UI or not.
415 vm.changeManagement.policyYN = "Y";
416 vm.changeManagement.sniroYN = "Y";
418 if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_ADD_MSO_TESTAPI_FIELD)) {
419 vm.changeManagement.testApi = DataService.getMsoRequestParametersTestApi();
422 widgetName: 'Portal-Common-Scheduler',
423 widgetData: vm.changeManagement,
424 widgetParameter: $scope.widgetParameter
427 window.parent.postMessage(data, VIDCONFIGURATION.SCHEDULER_PORTAL_URL);
430 vm.executeWorkflow = function () {
431 if (vm.localWorkflows && vm.localWorkflows.length > 0) {
432 vm.triggerLocalWorkflow();
434 vm.triggerRemoteWorkflow();
438 vm.triggerLocalWorkflow = function () {
439 var dataToSo = extractChangeManagementCallbackDataStr(vm.changeManagement);
441 var vnfName = vm.changeManagement.vnfNames[0].name;
442 changeManagementService.postChangeManagementNow(dataToSo, vnfName);
446 vm.triggerRemoteWorkflow = function () {
447 let cachedWorkflowDetails = vm.getCachedWorkflowDetails(vm.changeManagement.workflow);
448 if (cachedWorkflowDetails.length > 0) {
449 let workflowParameters = getWorkflowParametersFromForm();
450 if (workflowParameters) {
451 let servieInstanceId = vm.changeManagement.vnfNames[0]['service-instance-node'][0].properties['service-instance-id'];
452 let vnfInstanceId = vm.changeManagement.vnfNames[0].id;
453 let workflow_UUID = cachedWorkflowDetails[0].id;
454 changeManagementService.postWorkflowsParametersNow(servieInstanceId, vnfInstanceId, workflow_UUID, workflowParameters);
459 vm.loadSubscribers = function () {
461 AaiService.getSubscribers(function (response) {
462 vm.subscribers = response;
466 vm.loadServiceTypes = function () {
467 vm.serviceTypes = [];
469 AaiService.getSubscriberServiceTypes(vm.changeManagement.subscriberId)
470 .then(function (response) {
471 vm.serviceTypes = response.data;
473 .catch(function (error) {
478 vm.loadVNFTypes = function () {
480 vm.vnfTypesTemp = [];
481 vm.serviceInstances = [];
483 var instances = vm.changeManagement.serviceType["service-instances"]["service-instance"];
484 // var promiseArrOfGetVnfs = preparePromiseArrOfGetVnfs(instances);
489 AaiService.getVnfsByCustomerIdAndServiceType(
490 vm.changeManagement.subscriberId,
491 vm.changeManagement.serviceType["service-type"]
492 ).then(function (response) {
493 var vnfsData = response.data.results;
495 for (var i = 0; i < vnfsData.length; i++) {
497 const nodeType = vnfsData[i]['node-type'];
498 if (nodeType === "generic-vnf") {
499 if (_.find(vnfsData[i]['related-to'], function (node) {
500 return node['node-type'] === 'vserver'
502 vm.vnfs.push(vnfsData[i]);
504 } else if (nodeType === "service-instance") {
505 vm.serviceInstances.push(vnfsData[i]);
506 } else if (nodeType === "vf-module") {
507 vm.vfModules.push(vnfsData[i]);
512 vm.vnfs = _.flattenDeep(
513 _.remove(vm.vnfs, function (vnf) {
514 var nfRole = vnf.properties['nf-role'];
515 if (nfRole !== undefined) {
516 return nfRole !== 'null' && nfRole !== '';
521 var filteredVnfs = _.uniqBy(vm.vnfs, function (vnf) {
522 return vnf.properties['nf-role'];
525 _.forEach(filteredVnfs, function (vnf) {
526 vm.vnfTypes.push(vnf.properties['nf-role'])
533 var fromVNFVersions = [];
535 vm.loadVNFVersions = function () {
536 fromVNFVersions = [];
537 vm.serviceInstancesToGetVersions = [];
539 _.forEach(vm.vnfs, function (vnf) {
540 if (vnf.properties['nf-role'] === vm.changeManagement['vnfType']
541 && vnf.properties["model-invariant-id"]
542 && vnf.properties["model-version-id"]) {
543 vm.serviceInstancesToGetVersions.push({
544 "model-invariant-id": vnf.properties["model-invariant-id"],
545 "model-version-id": vnf.properties["model-version-id"]
549 versions.push(vnf.properties["model-invariant-id"]);
553 if (versions.length > 0) {
554 AaiService.getVnfVersionsByInvariantId(versions).then(function (response) {
557 $log.debug("getVnfVersionsByInvariantId: response", response);
559 fromVNFVersions = vm.serviceInstancesToGetVersions
560 .map(function (serviceInstanceToGetVersion) {
561 const model = _.find(response.data.model, {'model-invariant-id': serviceInstanceToGetVersion['model-invariant-id']});
562 $log.debug("getVnfVersionsByInvariantId: model for " + serviceInstanceToGetVersion['model-invariant-id'], model);
564 const modelVer = _.find(model["model-vers"]["model-ver"], {'model-version-id': serviceInstanceToGetVersion['model-version-id']});
565 $log.debug("getVnfVersionsByInvariantId: modelVer for " + serviceInstanceToGetVersion['model-version-id'], modelVer);
567 var modelVersionId = serviceInstanceToGetVersion["model-version-id"];
568 var modelVersion = modelVer["model-version"];
570 return {"key": modelVersionId, "value": modelVersion};
573 vm.fromVNFVersions = _.uniqBy(fromVNFVersions, 'value');
580 function getVnfs(modelInvariantId) {
581 return new Promise(function (resolve, reject) {
582 AaiService.getVnfVersionsByInvariantId(modelInvariantId)
583 .then(function (response) {
584 if (response.data.httpCode !== null &&
585 response.data.httpCode === 200) {
586 var vnfsData = response.data.t.results;
587 for (var i = 0; i < vnfsData.length; i++) {
589 if (vnfsData[i].nodeType === "generic-vnf") {
590 resolve(vnfsData[i]);
591 } else if (vnfsData[i].nodeType === "service-instance") {
592 vm.serviceInstances.push(vnfsData[i]);
600 .catch(function (error) {
606 var getVersionNameForId = function(versionId) {
607 var version = _.find(fromVNFVersions, {"key": versionId});
608 return version.value;
611 vm.loadVNFNames = function () {
613 const vnfs = vm.changeManagement.fromVNFVersion ? vm.vnfs : [];
614 _.forEach(vnfs, function (vnf) {
616 var selectedVersionNumber = getVersionNameForId(vm.changeManagement.fromVNFVersion);
618 if (vnf.properties['nf-role'] === vm.changeManagement.vnfType &&
619 selectedVersionNumber === getVersionNameForId(vnf.properties["model-version-id"])) {
622 _.forEach(vnf['related-to'], function (node) {
623 if (node['node-type'] === 'vserver') {
624 vServer = extractLcpRegionIdAndTenantId(node.url);
628 var serviceInstancesIds =
629 _.filter(vnf['related-to'], {'node-type': 'service-instance'})
630 .map(function (serviceInstance) { return serviceInstance.id });
632 var serviceInstances = _.filter(vm.serviceInstances, function(serviceInstance) {
633 return _.includes(serviceInstancesIds, serviceInstance.id);
637 if (serviceInstancesIds.length === 0) {
638 $log.error("loadVNFNames: no serviceInstancesIds for vnf", vnf);
640 $log.debug("loadVNFNames: serviceInstancesIds", serviceInstancesIds);
641 $log.debug("loadVNFNames: serviceInstances", serviceInstances);
645 "id": vnf.properties["vnf-id"],
646 "name": vnf.properties["vnf-name"],
647 "invariant-id": vnf.properties["model-invariant-id"],
648 "service-instance-node": serviceInstances,
649 "modelVersionId": vnf.properties["model-version-id"],
650 "properties": vnf.properties,
651 'cloudConfiguration': vServer,
652 "relatedTo": vnf['related-to']
658 function extractLcpRegionIdAndTenantId(url) {
660 var cloudConfiguration = {
661 lcpCloudRegionId: '',
666 e.g., in both URLs below -
667 Â - lcpCloudRegionId == 'rdm5b'
668 Â - tenantId == '0675e0709bd7444a9e13eba8b40edb3c'
670 "url": "https://aai-conexus-e2e.ecomp.cci.att.com:8443/aai/v10/cloud-infrastructure/cloud-regions/cloud-region/att-aic/rdm5b/tenants/tenant/0675e0709bd7444a9e13eba8b40edb3c/vservers/vserver/932b330d-733e-427d-a519-14eebd261f70"
671 "url": "/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/att-aic/rdm5b/tenants/tenant/0675e0709bd7444a9e13eba8b40edb3c/vservers/vserver/932b330d-733e-427d-a519-14eebd261f70"
674 var cloudRegionMatch = url.match(/\/cloud-regions\/cloud-region\/[^\/]+\/([^\/]+)/);
675 var tenantMatch = url.match(/\/tenants\/tenant\/([^\/]+)/);
677 cloudConfiguration.lcpCloudRegionId = cloudRegionMatch[1];
678 cloudConfiguration.tenantId = tenantMatch[1];
680 return cloudConfiguration;
683 vm.loadWorkFlows = function () {
684 if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_HANDLE_SO_WORKFLOWS)) {
685 return vm.loadRemoteWorkFlows()
687 vm.workflows = vm.remoteWorkflows.map(item => item.name);
688 }).then(function () {
689 vm.loadRemoteWorkFlowsParameters();
692 return vm.loadLocalWorkFlows()
693 .then(vm.loadLocalWorkFlowsParameters)
695 vm.workflows = vm.localWorkflows;
700 vm.loadLocalWorkFlows = function () {
701 return changeManagementService.getWorkflows(vm.changeManagement.vnfNames)
702 .then(function (response) {
703 vm.localWorkflows = response.data.workflows || [];
704 }).catch(function (error) {
709 vm.loadRemoteWorkFlows = function () {
710 let vnfModelIDs = vm.changeManagement.vnfNames.map(vnfName => vnfName.modelVersionId);
711 return changeManagementService.getSOWorkflows(vnfModelIDs)
712 .then(function (response) {
713 vm.remoteWorkflows = response.data || [];
714 }).catch(function (error) {
719 vm.loadLocalWorkFlowsParameters = function () {
720 vm.localWorkflowsParameters = new Map();
721 vm.localWorkflows.forEach(function(workflow) {
722 vm.loadLocalWorkFlowParameters(workflow);
726 vm.loadLocalWorkFlowParameters = function (workflow) {
727 changeManagementService.getLocalWorkflowParameter(workflow)
728 .then(function (response) {
729 let fileParameters = response.data.parameterDefinitions.filter(item => item.type === 'FILE');
730 let textParameters = response.data.parameterDefinitions.filter(item => item.type === 'STRING');
731 let parameters = new Map();
732 parameters.set('FILE', fileParameters);
733 parameters.set('STRING', textParameters);
734 vm.localWorkflowsParameters.set(workflow, parameters);
736 .catch(function (error) {
741 vm.loadRemoteWorkFlowsParameters = function () {
742 vm.remoteWorkflowsParameters = new Map();
743 vm.remoteWorkflows.forEach(function(workflow) {
744 vm.loadRemoteWorkFlowParameters(workflow);
748 vm.loadRemoteWorkFlowParameters = function (workflow) {
750 workflow.workflowInputParameters
751 .filter( function (param) {
752 return param.soPayloadLocation === "userParams"
754 .forEach(function (param) {
755 let workflowParams = vm.repackAttributes(param);
756 if (param.validation.length > 0) {
757 let validation = param.validation[0];
758 if ('maxLength' in validation) {
759 workflowParams.maxLength = validation.maxLength;
761 if ('allowableChars' in validation) {
762 workflowParams.pattern = validation.allowableChars;
765 parameters.push(workflowParams);
768 vm.remoteWorkflowsParameters.set(workflow.name, parameters);
771 vm.repackAttributes = function (workflowParam){
773 name: workflowParam.label,
774 required: workflowParam.required,
775 id: workflowParam.soFieldName,
776 soFieldName: workflowParam.soFieldName,
782 vm.getRemoteWorkFlowParameters = function (workflow) {
783 if (workflow && vm.remoteWorkflowsParameters.has(workflow)) {
784 return vm.remoteWorkflowsParameters.get(workflow)
789 vm.getInternalWorkFlowParameters = function (workflow, type) {
790 if (workflow && vm.localWorkflowsParameters.has(workflow) && vm.localWorkflowsParameters.get(workflow).has(type)) {
791 return vm.localWorkflowsParameters.get(workflow).get(type)
796 vm.getInternalWorkFlowParameter = function (workflow, type, parameterName) {
797 if (workflow && vm.localWorkflowsParameters.has(workflow) && vm.localWorkflowsParameters.get(workflow).has(type)) {
798 return vm.localWorkflowsParameters.get(workflow).get(type).filter(parameter => parameter.name === parameterName)[0]
802 vm.getCachedWorkflowDetails = function (workflow) {
803 return vm.remoteWorkflows.filter( function (remoteWorkflow) {
804 return remoteWorkflow.name === workflow;
809 //Must be $scope because we bind to the onchange of the html (cannot attached to vm variable).
810 $scope.selectFileForVNFName = function (fileInput) {
811 if (fileInput && fileInput.id) {
812 var vnfName = _.filter(vm.changeManagement.vnfNames, {"invariant-id": fileInput.id});
813 var file = fileInput.files[0];
814 var fileReader = new FileReader();
815 fileReader.onload = function (load) {
817 var lines = load.target.result;
818 vnfName[0].selectedFile = JSON.parse(lines);
823 fileReader.readAsText(file);
827 vm.selectVersionForVNFName = function (vnfName) {
828 console.log("Will add version for selected vnf name: " + vnfName.name);
831 vm.isConfigUpdate = function () {
832 return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfConfigUpdate;
835 vm.isScaleOut = function () {
836 return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfScaleOut;
839 vm.shouldShowVnfInPlaceFields = function () {
840 return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfInPlace;
843 vm.setPreload = function (fileEl) {
844 var files = fileEl.files;
846 var reader = new FileReader();
848 reader.onloadend = function(evt) {
849 if (evt.target.readyState === FileReader.DONE) {
850 $scope.$apply(function () {
851 $scope.moduleArr[0].userParams = JSON.parse(evt.target.result);
856 reader.readAsText(file);