+/*-
+ * ============LICENSE_START=======================================================
+ * VID
+ * ================================================================================
+ * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
(function () {
'use strict';
- appDS2.controller("newChangeManagementModalController", ["$uibModalInstance", "$uibModal", "AaiService", "changeManagementService",
- "$log", "$scope", "_", newChangeManagementModalController]);
+ appDS2.controller("newChangeManagementModalController", ["$uibModalInstance", "$uibModal",'$q', "AaiService", "changeManagementService", "Upload",
+ "$log", "$scope", "_", "COMPONENT", "VIDCONFIGURATION","DataService","featureFlags", newChangeManagementModalController]);
+
+ function newChangeManagementModalController($uibModalInstance, $uibModal,$q, AaiService, changeManagementService, Upload, $log, $scope, _, COMPONENT, VIDCONFIGURATION, DataService, featureFlags) {
+
- function newChangeManagementModalController($uibModalInstance, $uibModal, AaiService, changeManagementService, $log, $scope, _) {
var vm = this;
+ vm.hasScheduler = !!VIDCONFIGURATION.SCHEDULER_PORTAL_URL;
+ vm.errorMsg='';
+
+ vm.wizardStep = 1;
+ vm.nextStep = function(){
+ vm.wizardStep++;
+ $(".modal-dialog").animate({"width":"1200px"},400,'linear');
+ };
+ vm.prevStep = function(){
+ vm.wizardStep--;
+ $(".modal-dialog").animate({"width":"600px"},400,'linear');
+ };
+
+ vm.softwareVersionRegex = "[-a-zA-Z0-9\.]+";
+
+ var attuid;
+
+ $scope.showReportWindow = function() {
+ const modalWindow = $uibModal.open({
+ templateUrl: 'app/vid/scripts/modals/report-modal/report-modal.html',
+ controller: 'reportModalController',
+ controllerAs: 'vm',
+ resolve: {
+ errorMsg: function () {
+ return vm.errorMsg.message;
+ }
+ }
+ });
+
+ };
+
+ $scope.isShowErrorReport = function() {
+ return featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_CREATE_ERROR_REPORTS);
+ };
+
+ function fetchAttUid() {
+ var defer = $q.defer();
+ if (attuid) {
+ defer.resolve(attuid);
+ } else {
+ AaiService.getLoggedInUserID(function (response) {
+ attuid = response.data;
+ defer.resolve(attuid);
+ },
+ function (err) {
+ defer.reject(err);
+ vm.errorMsg = err;
+ });
+ }
+ return defer.promise;
+ }
var init = function () {
vm.changeManagement = {};
+ vm.changeManagement.workflowParameters = new Map();
loadServicesCatalog();
- registerVNFNamesWatcher();
+ fetchAttUid().then(registerVNFNamesWatcher);
vm.loadSubscribers();
};
})
.catch(function (error) {
$log.error(error);
+ vm.errorMsg = err;
})
};
_.each(response.data.vnfs, function (vnf) {
if (newVNFName["invariant-id"] === vnf.invariantUuid) {
availableVersions.push(extractVNFModel(vnf, response.data.service, newVNFName));
+
+ //for scale out screen
+ if(service.uuid === newVNFName["service-instance-node"][0].properties["model-version-id"]) {
+ newVNFName.vfModules = vnf.vfModules;
+ newVNFName.category = response.data.service.category;
+ newVNFName.groupModules = _.groupBy(newVNFName.vfModules, "customizationUuid");
+
+ //list vfmodules ids in AAI that belong to that vnf instance
+ var modulesAaiIds = _.filter(newVNFName.relatedTo, function(item){
+ return item["node-type"] === "vf-module";
+ }).map(function(item){
+ return item.id;
+ });
+
+ _.forEach(newVNFName.vfModules, function (mdl, key) {
+ mdl.scale = false; //defaults to not scale unless user changes it
+ if(mdl.properties && mdl.properties.maxCountInstances) {
+
+ //how many vf modules of the same customizationId belong to that vnf instance
+ mdl.currentCount = _.filter(vm.vfModules, function(item){
+ return modulesAaiIds.indexOf(item.id) > -1 && item.properties["model-customization-id"] === mdl.customizationUuid;
+ }).length;
+
+ mdl.scalable = mdl.properties.maxCountInstances - mdl.currentCount > 0;
+ }else{
+ mdl.scalable = false;
+ }
+ });
+ }
}
});
- var versions = _.uniqBy(availableVersions, ['modelInfo.modelVersion']);
- newVNFName.availableVersions = _.uniq(versions, response.data.service, true);
+ var versions = _.uniqBy(availableVersions, 'modelInfo.modelVersion');
+ newVNFName.availableVersions = _.sortBy(_.uniq(versions, response.data.service, true),"modelInfo.modelVersion");
}).catch(function (error) {
$log.error(error);
+ vm.errorMsg = error;
});
});
}
};
var extractVNFModel = function (csarVNF, sdcService, selectionVNF) {
+ /**
+ @param selectionVNF A vnf *instance* selected in "available VNF" drop-down box
+ @param csarVNF A VNF *MODEL* that has an invariantUuid same as selectionVNF (might be
+ a different version; i.e. selectionVNF.modelVersionId <> csarVNF.uuid)
+ @param sdcService The Service *MODEL* which has the related VNF `csarVNF`.
+ */
var versionCsarData = {
vnfInstanceId: "",
vnfName: csarVNF.name,
modelInfo: {
modelType: "vnf",
modelInvariantId: csarVNF.invariantUuid,
- modelVersionId: selectionVNF.modelVersionId,
+ modelVersionId: csarVNF.uuid,
modelName: csarVNF.name,
modelVersion: csarVNF.version,
modelCustomizationName: csarVNF.modelCustomizationName,
modelCustomizationId: csarVNF.customizationUuid
},
- cloudConfiguration: {
- lcpCloudRegionId: "mdt1",
- tenantId: "88a6ca3ee0394ade9403f075db23167e"
- },
+ cloudConfiguration: selectionVNF.cloudConfiguration || {},
requestInfo: {
source: "VID",
suppressRollback: false,
- requestorId: "az2016"
+ requestorId: attuid
},
relatedInstanceList: [
{
instanceId: selectionVNF["service-instance-node"]["0"].properties['service-instance-id'],
modelInfo: {
modelType: "service",
- modelInvariantId: selectionVNF["service-instance-node"]["0"].properties['model-invariant-id'],
- modelVersionId: selectionVNF.modelVersionId,
+ modelInvariantId: sdcService.invariantUuid,
+ modelVersionId: sdcService.uuid,
modelName: sdcService.name,
- modelVersion: sdcService.version,
- modelCustomizationName: selectionVNF["service-instance-node"]["0"].properties['model-customization-name'], //TODO: Missing
- modelCustomizationId: selectionVNF["service-instance-node"]["0"].properties['model-customization-id']
+ modelVersion: sdcService.version
}
}
}
$uibModalInstance.close();
};
- vm.schedule = function () {
- $uibModalInstance.close(vm.changeManagement);
+ vm.uploadConfigFile = function (file) {
+ var defer = $q.defer();
+ Upload.upload({
+ url: "change-management/uploadConfigUpdateFile",
+ file: file,
+ transformResponse: [function (data) {
+ return data;
+ }]
+ })
+ .then(function (configUpdateResponse) {
+ vm.getInternalWorkFlowParameter("VNF Config Update", "FILE", "Attach configuration file").value = configUpdateResponse && JSON.parse(configUpdateResponse.data).payload;
+ defer.resolve(true);
+ })
+ .catch(function (error) {
+ defer.resolve(false);
+ });
+ return defer.promise;
+ };
- var modalInstance = $uibModal.open({
- templateUrl: 'app/vid/scripts/modals/new-scheduler/new-scheduler.html',
- controller: 'newSchedulerController',
- controllerAs: 'vm',
- resolve: {
- changeManagement: function () {
- return vm.changeManagement;
+
+ /***converting objects to scheduler format (taken from IST) - was altered for Scale out support ***/
+ function extractChangeManagementCallbackDataStr(changeManagement) {
+ console.log(changeManagement);
+ var result = {};
+ result.requestType = changeManagement.workflow;
+ var workflowType = changeManagement.workflow;
+ result.requestDetails = [];
+ _.forEach(changeManagement.vnfNames, function (vnf) {
+
+ try{
+ var requestInfoData ={};
+ var requestParametersData ={};
+ var moduleToScale = _.find(vnf.vfModules, {"scale": true});
+ if (vnf.availableVersions && vnf.availableVersions.length!=0){
+
+ requestInfoData ={
+ source: vnf.availableVersions[0].requestInfo.source,
+ suppressRollback: vnf.availableVersions[0].requestInfo.suppressRollback,
+ requestorId: vnf.availableVersions[0].requestInfo.requestorId
+ }
+
+ if(workflowType=='Update'){
+ requestParametersData = {
+ usePreload: vnf.availableVersions[0].requestParameters.usePreload
+ }
+ }else if(workflowType=="Replace"){
+ requestParametersData = {
+ rebuildVolumeGroups: vnf.availableVersions[0].requestParameters.usePreload
+ }
+ }else if(workflowType=="VNF In Place Software Update"){
+ var payloadObj = {
+ 'existing_software_version':vm.getInternalWorkFlowParameter(workflowType, 'text', 'Existing software version').value,
+ 'new_software_version':vm.getInternalWorkFlowParameter(workflowType, 'text', 'New software version').value,
+ 'operations_timeout':vm.getInternalWorkFlowParameter(workflowType, 'text', 'Operations timeout').value
+ };
+ requestParametersData = {
+ payload: JSON.stringify(payloadObj)
+ }
+ }else if(workflowType=="VNF Config Update"){
+ requestParametersData = {
+ payload: vm.getInternalWorkFlowParameter("VNF Config Update", "FILE", "Attach configuration file").value
+ }
+ }else if(workflowType=="VNF Scale Out"){
+ if(!moduleToScale) return null;
+
+ if(moduleToScale.userParams) {
+ requestParametersData = {
+ userParams: moduleToScale.userParams
+ //,usePreload: true
+ }
+ }else{
+ requestParametersData = {
+ userParams: []
+ //,usePreload: false
+ }
+ }
+ }
+ $log.info('SchedulerWidgetCtrl:extractChangeManagementCallbackDataStr info:: workflowType '+ workflowType);
+ $log.info('SchedulerWidgetCtrl:extractChangeManagementCallbackDataStr info:: requestParametersData '+ requestParametersData);
+
+ }else if(workflowType=="VNF In Place Software Update"){
+ var payloadObj = {
+ 'existing_software_version':vm.getInternalWorkFlowParameter(workflowType, 'text', 'Existing software version').value,
+ 'new_software_version':vm.getInternalWorkFlowParameter(workflowType, 'text', 'New software version').value,
+ 'operations_timeout':vm.getInternalWorkFlowParameter(workflowType, 'text', 'Operations timeout').value
+ };
+ requestParametersData = {
+ payload: JSON.stringify(payloadObj)
+ }
+ }else if(workflowType=="VNF Config Update"){
+ requestParametersData = {
+ payload: vm.getInternalWorkFlowParameter("VNF Config Update", "FILE", "Attach configuration file").value
+ }
}
+
+ var data;
+ if(workflowType=="VNF Scale Out") {
+ data = {
+ vnfName: vnf.name,
+ vnfInstanceId: vnf.id,
+ modelInfo: {
+ modelType: 'vfModule',
+ modelInvariantId: moduleToScale.invariantUuid,
+ modelName: moduleToScale.modelCustomizationName,
+ modelVersion: moduleToScale.version,
+ modelCustomizationName: moduleToScale.modelCustomizationName,
+ modelCustomizationId: moduleToScale.customizationUuid,
+ modelVersionId: moduleToScale.uuid
+ },
+ cloudConfiguration: vnf.cloudConfiguration,
+ requestInfo: requestInfoData,
+ relatedInstanceList: [],
+ requestParameters:requestParametersData,
+ configurationParameters: JSON.parse(vm.getInternalWorkFlowParameter("VNF Scale Out", "text", "Configuration Parameters").value)
+ };
+ requestInfoData.instanceName = vnf.name + "_" + (moduleToScale.currentCount + 1);
+ }else{
+ data = {
+ vnfName: vnf.name,
+ vnfInstanceId: vnf.id,
+ modelInfo: {
+ modelType: 'vnf',
+ modelInvariantId: vnf.properties['model-invariant-id'],
+ modelVersionId: vnf.modelVersionId,
+ modelName: vnf.properties['vnf-name'],
+ modelVersion: vnf.version,
+ modelCustomizationName: vnf.properties['model-customization-name'],
+ modelCustomizationId: vnf.properties['model-customization-id']
+ },
+ cloudConfiguration: vnf.cloudConfiguration,
+ requestInfo: requestInfoData,
+ relatedInstanceList: [],
+ requestParameters:requestParametersData
+ };
+ }
+
+ var serviceInstanceId = '';
+ _.forEach(vnf['service-instance-node'], function (instanceNode) {
+ if(instanceNode['node-type'] === 'service-instance'){
+ serviceInstanceId = instanceNode.properties['service-instance-id'];
+ }
+ });
+
+ if (vnf.availableVersions && vnf.availableVersions.length!=0){
+ _.forEach(vnf.availableVersions[0].relatedInstanceList, function (related) {
+ var rel = related.relatedInstance;
+ var relatedInstance = {
+ instanceId: serviceInstanceId,
+ modelInfo: {
+ modelType: rel.modelInfo.modelType,
+ modelInvariantId: rel.modelInfo.modelInvariantId,
+ modelVersionId: rel.modelInfo.modelVersionId,
+ modelName: rel.modelInfo.modelName,
+ modelVersion: rel.modelInfo.modelVersion,
+ modelCustomizationName: rel.modelInfo.modelCustomizationName,
+ modelCustomizationId: rel.modelInfo.modelCustomizationId
+ }
+ };
+ if (rel.vnfInstanceId)
+ relatedInstance.instanceId = rel.vnfInstanceId;
+
+ data.relatedInstanceList.push({relatedInstance: relatedInstance});
+ });
+ if(workflowType=="VNF Scale Out") {
+ //push vnf to related as well as the service instance
+ var relatedInstance = {
+ instanceId: vnf.id,
+ modelInfo: {
+ modelCustomizationId: vnf.availableVersions[0].modelInfo.modelCustomizationId,
+ modelCustomizationName: vnf.availableVersions[0].modelInfo.modelCustomizationName,
+ modelInvariantId: vnf.availableVersions[0].modelInfo.modelInvariantId,
+ modelName: vnf.availableVersions[0].modelInfo.modelName,
+ modelType: vnf.availableVersions[0].modelInfo.modelType,
+ modelVersion: vnf.availableVersions[0].modelInfo.modelVersion,
+ modelVersionId: vnf.availableVersions[0].modelInfo.modelVersionId
+ }
+ };
+ data.relatedInstanceList.push({relatedInstance: relatedInstance});
+ }
+ }
+ }catch(err){
+ $log.error('SchedulerCtrl::extractChangeManagementCallbackDataStr error: ' + err);
+ vm.errorMsg = err;
}
+
+ result.requestDetails.push(data);
});
+ return JSON.stringify(result);
+ }
- modalInstance.result.then(function (result) {
- console.log("This is the result of the new change management modal.", result);
- })
+ function getWorkflowParametersFromForm() {
+ let workflowParameters =
+ {requestDetails:{
+ cloudConfiguration:{},
+ requestParameters:{userParams:[{}]}
+ }};
+ workflowParameters.requestDetails.cloudConfiguration = vm.changeManagement.vnfNames[0].cloudConfiguration;
+
+ let parameters = vm.getRemoteWorkFlowParameters(vm.changeManagement.workflow);
+ parameters.forEach((parameter)=>{
+ let inputField = document.getElementById('so-workflow-parameter-'+parameter.soFieldName);
+ workflowParameters.requestDetails.requestParameters.userParams[0][parameter.soFieldName]=inputField.value;
+ });
+
+ return workflowParameters;
+ }
+
+ vm.openModal = function () {
+ if(vm.hasScheduler) { //scheduling supported
+ vm.scheduleWorkflow();
+ } else {
+ //no scheduling support
+ vm.executeWorkflow();
+ }
+ };
+
+ vm.scheduleWorkflow = function () {
+ $scope.widgetParameter = ""; // needed by the scheduler?
+
+ // properties needed by the scheduler so it knows whether to show
+ // policy or sniro related features on the scheduler UI or not.
+ vm.changeManagement.policyYN = "Y";
+ vm.changeManagement.sniroYN = "Y";
+
+ if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_ADD_MSO_TESTAPI_FIELD)) {
+ vm.changeManagement.testApi = DataService.getMsoRequestParametersTestApi();
+ }
+ var data = {
+ widgetName: 'Portal-Common-Scheduler',
+ widgetData: vm.changeManagement,
+ widgetParameter: $scope.widgetParameter
+ };
+
+ window.parent.postMessage(data, VIDCONFIGURATION.SCHEDULER_PORTAL_URL);
+ };
+
+ vm.executeWorkflow = function () {
+ if ( vm.localWorkflows && vm.localWorkflows.length > 0 ) {
+ vm.triggerLocalWorkflow();
+ } else {
+ let source = vm.getRemoteWorkflowSource(vm.changeManagement.workflow);
+ if( source === "NATIVE"){
+ vm.triggerLocalWorkflow();
+ }else {
+ vm.triggerRemoteWorkflow();
+ }
+ }
+ };
+
+ vm.triggerLocalWorkflow = function () {
+ var dataToSo = extractChangeManagementCallbackDataStr(vm.changeManagement);
+ if (dataToSo) {
+ var vnfName = vm.changeManagement.vnfNames[0].name;
+ changeManagementService.postChangeManagementNow(dataToSo, vnfName);
+ }
+ };
+
+ vm.triggerRemoteWorkflow = function () {
+ let cachedWorkflowDetails = vm.getCachedWorkflowDetails(vm.changeManagement.workflow);
+ if (cachedWorkflowDetails.length > 0) {
+ let workflowParameters = getWorkflowParametersFromForm();
+ if (workflowParameters) {
+ let servieInstanceId = vm.changeManagement.vnfNames[0]['service-instance-node'][0].properties['service-instance-id'];
+ let vnfInstanceId = vm.changeManagement.vnfNames[0].id;
+ let workflow_UUID = cachedWorkflowDetails[0].id;
+ changeManagementService.postWorkflowsParametersNow(servieInstanceId, vnfInstanceId, workflow_UUID, workflowParameters);
+ }
+ }
};
vm.loadSubscribers = function () {
})
.catch(function (error) {
$log.error(error);
+ vm.errorMsg = error;
});
};
// var promiseArrOfGetVnfs = preparePromiseArrOfGetVnfs(instances);
vm.vnfs = [];
+ vm.vfModules = [];
AaiService.getVnfsByCustomerIdAndServiceType(
vm.changeManagement.subscriberId,
if (vnfsData[i]) {
const nodeType = vnfsData[i]['node-type'];
if (nodeType === "generic-vnf") {
- _.forEach(vnfsData[i]['related-to'], function (node) {
- if (node['node-type'] === 'vserver') {
- vm.vnfs.push(vnfsData[i]);
- }
- })
+ if (_.find(vnfsData[i]['related-to'], function (node) {
+ return node['node-type'] === 'vserver'
+ }) !== undefined) {
+ vm.vnfs.push(vnfsData[i]);
+ }
} else if (nodeType === "service-instance") {
vm.serviceInstances.push(vnfsData[i]);
+ } else if (nodeType === "vf-module") {
+ vm.vfModules.push(vnfsData[i]);
}
}
}
);
};
+ var fromVNFVersions = [];
+
vm.loadVNFVersions = function () {
- vm.fromVNFVersions = [];
+ fromVNFVersions = [];
vm.serviceInstancesToGetVersions = [];
var versions = [];
_.forEach(vm.vnfs, function (vnf) {
- if (vnf.properties['nf-role'] === vm.changeManagement['vnfType']) {
+ if (vnf.properties['nf-role'] === vm.changeManagement['vnfType']
+ && vnf.properties["model-invariant-id"]
+ && vnf.properties["model-version-id"]) {
+ vm.serviceInstancesToGetVersions.push({
+ "model-invariant-id": vnf.properties["model-invariant-id"],
+ "model-version-id": vnf.properties["model-version-id"]
+ }
+ );
+
+ versions.push(vnf.properties["model-invariant-id"]);
+ }
+ });
- vm.serviceInstancesToGetVersions.push(vnf);
+ if (versions.length > 0) {
+ AaiService.getVnfVersionsByInvariantId(versions).then(function (response) {
+ if (response.data) {
- versions.push(vnf.properties["model-invariant-id"]);
+ $log.debug("getVnfVersionsByInvariantId: response", response);
+ fromVNFVersions = vm.serviceInstancesToGetVersions
+ .map(function (serviceInstanceToGetVersion) {
+ const model = _.find(response.data.model, {'model-invariant-id': serviceInstanceToGetVersion['model-invariant-id']});
+ $log.debug("getVnfVersionsByInvariantId: model for " + serviceInstanceToGetVersion['model-invariant-id'], model);
- }
- });
+ const modelVer = _.find(model["model-vers"]["model-ver"], {'model-version-id': serviceInstanceToGetVersion['model-version-id']});
+ $log.debug("getVnfVersionsByInvariantId: modelVer for " + serviceInstanceToGetVersion['model-version-id'], modelVer);
- AaiService.getVnfVersionsByInvariantId(versions).then(function (response) {
- if (response.data) {
- var key = response.data.model["0"]["model-invariant-id"];
- var value = response.data.model["0"]["model-vers"]["model-ver"]["0"]["model-version"];
- var element = {"key": key, "value": value};
- vm.fromVNFVersions.push(element);
- }
- //TODO promise all and call the new api to get the versions.
- // vm.fromVNFVersions.push(response.data.model["0"]["model-vers"]["model-ver"]["0"]["model-version"]);
- // if(vm.serviceInstancesToGetVersions.length > 0){
- //
- // var promiseArrOfGetVnfs = preparePromiseArrOfGetVersions('a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb');
- //
- // Promise.all(promiseArrOfGetVnfs).then(function (allData) {
- // vm.vnfs = _.flattenDeep(_.without(allData, null));
- // var filteredVnfs = _.sortedUniqBy(vm.vnfs, function (vnf) {
- // return vnf.properties.vnfType;
- // });
- //
- // _.forEach(filteredVnfs, function (vnf) {
- // vm.vnfTypes.push(vnf.properties.vnfType)
- // });
- //
- // }).catch(function (error) {
- // $log(error);
- // });
- // }
- })
- // debugger;
+ var modelVersionId = serviceInstanceToGetVersion["model-version-id"];
+ var modelVersion = modelVer["model-version"];
+
+ return {"key": modelVersionId, "value": modelVersion};
+ });
+ vm.fromVNFVersions = _.uniqBy(fromVNFVersions, 'value');
+ }
+ })
+ }
};
- // function preparePromiseArrOfGetVersions(serviceInstances) {
- // var promiseArr = [];
- // for (var i = 0; i < serviceInstances.length; i++) {
- // var modelInvariantId = serviceInstances[i].properties["model-invariant-id"];
- // promiseArr.push(
- // getVnfs(modelInvariantId)
- // );
- // }
- // return promiseArr;
- // }
function getVnfs(modelInvariantId) {
return new Promise(function (resolve, reject) {
})
.catch(function (error) {
reject(error);
+ vm.errorMsg = error;
});
});
}
+ var getVersionNameForId = function(versionId) {
+ var version = _.find(fromVNFVersions, {"key": versionId});
+ return version.value;
+ };
+
vm.loadVNFNames = function () {
vm.vnfNames = [];
+ const vnfs = vm.changeManagement.fromVNFVersion ? vm.vnfs : [];
+ _.forEach(vnfs, function (vnf) {
- _.forEach(vm.vnfs, function (vnf) {
+ var selectedVersionNumber = getVersionNameForId(vm.changeManagement.fromVNFVersion);
- if (vnf.properties['nf-role'] === vm.changeManagement.vnfType) {
+ if (vnf.properties['nf-role'] === vm.changeManagement.vnfType &&
+ selectedVersionNumber === getVersionNameForId(vnf.properties["model-version-id"])) {
var vServer = {};
_.forEach(vnf['related-to'], function (node) {
}
});
+ var serviceInstancesIds =
+ _.filter(vnf['related-to'], {'node-type': 'service-instance'})
+ .map(function (serviceInstance) { return serviceInstance.id });
+
+ var serviceInstances = _.filter(vm.serviceInstances, function(serviceInstance) {
+ return _.includes(serviceInstancesIds, serviceInstance.id);
+ });
+
+ // logging only
+ if (serviceInstancesIds.length === 0) {
+ $log.error("loadVNFNames: no serviceInstancesIds for vnf", vnf);
+ } else {
+ $log.debug("loadVNFNames: serviceInstancesIds", serviceInstancesIds);
+ $log.debug("loadVNFNames: serviceInstances", serviceInstances);
+ }
+
vm.vnfNames.push({
"id": vnf.properties["vnf-id"],
"name": vnf.properties["vnf-name"],
"invariant-id": vnf.properties["model-invariant-id"],
- "service-instance-node": _.filter(vm.serviceInstances, {id: vnf["related-to"][0].id}),
+ "service-instance-node": serviceInstances,
"modelVersionId": vnf.properties["model-version-id"],
"properties": vnf.properties,
'cloudConfiguration': vServer,
tenantId: ''
};
- var splitedUrlByDash = _.split(url, '/', 100);
+ /*
+ e.g., in both URLs below -
+ - lcpCloudRegionId == 'rdm5b'
+ - tenantId == '0675e0709bd7444a9e13eba8b40edb3c'
- cloudConfiguration.lcpCloudRegionId = splitedUrlByDash[7];
- cloudConfiguration.tenantId = splitedUrlByDash[10];
+ "url": "https://aai-conexus-e2e.ecomp.cci.att.com:8443/aai/v10/cloud-infrastructure/cloud-regions/cloud-region/irma-aic/rdm5b/tenants/tenant/0675e0709bd7444a9e13eba8b40edb3c/vservers/vserver/932b330d-733e-427d-a519-14eebd261f70"
+ "url": "/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/irma-aic/rdm5b/tenants/tenant/0675e0709bd7444a9e13eba8b40edb3c/vservers/vserver/932b330d-733e-427d-a519-14eebd261f70"
+ */
+
+ var cloudRegionMatch = url.match(/\/cloud-regions\/cloud-region\/[^\/]+\/([^\/]+)/);
+ var tenantMatch = url.match(/\/tenants\/tenant\/([^\/]+)/);
+
+ cloudConfiguration.lcpCloudRegionId = cloudRegionMatch[1];
+ cloudConfiguration.tenantId = tenantMatch[1];
return cloudConfiguration;
};
vm.loadWorkFlows = function () {
- var vnfs = [];
- angular.forEach(vm.changeManagement.vnfNames, function (vnfName) {
- vnfs.push(vnfName.name)
+ vm.localWorkflowsParameters = new Map();
+ vm.remoteWorkflowsParameters = new Map();
+ if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_HANDLE_SO_WORKFLOWS)) {
+ return vm.loadRemoteWorkFlows()
+ .then(function () {
+ vm.workflows = vm.remoteWorkflows.map(item => item.name);
+ }).then(function () {
+ vm.loadRemoteWorkFlowsParameters();
+ });
+ }else{
+ return vm.loadLocalWorkFlows()
+ .then(vm.loadLocalWorkFlowsParameters)
+ .then(function () {
+ vm.workflows = vm.localWorkflows;
+ })
+ }
+ };
+
+ vm.loadLocalWorkFlows = function () {
+ return changeManagementService.getWorkflows(vm.changeManagement.vnfNames)
+ .then(function (response) {
+ vm.localWorkflows = response.data.workflows || [];
+ }).catch(function (error) {
+ $log.error(error);
+ vm.errorMsg = error;
+ });
+ };
+
+ vm.loadRemoteWorkFlows = function () {
+ let vnfModelIDs = vm.changeManagement.vnfNames.map(vnfName => vnfName.modelVersionId);
+ return changeManagementService.getSOWorkflows(vnfModelIDs)
+ .then(function (response) {
+ vm.remoteWorkflows = response.data || [];
+ }).catch(function (error) {
+ $log.error(error);
+ vm.errorMsg = error;
+ });
+ };
+
+ vm.loadLocalWorkFlowsParameters = function () {
+ vm.localWorkflows.forEach(function(workflow) {
+ vm.loadLocalWorkFlowParameters(workflow);
});
+ };
- //TODO: When we'll have the mappings, use the backend call to get the workflows
- // changeManagementService.getWorkflows(vnfs)
- // .then(function(response) {
- // vm.workflows = response.data;
- // })
- // .catch(function(error) {
- // $log.error(error);
- // });
+ vm.loadLocalWorkFlowParameters = function (workflow) {
+ changeManagementService.getLocalWorkflowParameter(workflow)
+ .then(function (response) {
+ vm.localWorkflowsParameters.set(workflow, response.data.parameterDefinitions);
+ })
+ .catch(function (error) {
+ $log.error(error);
+ vm.errorMsg = error;
+ });
+ };
+
+ vm.loadRemoteWorkFlowsParameters = function () {
+ vm.remoteWorkflows.forEach(function(workflow) {
+ if (workflow.source ==='SDC' || workflow.source === 'sdc' ){
+ vm.loadRemoteWorkFlowParameters(workflow);
+ } else {
+ vm.loadLocalWorkFlowParameters(workflow.name);
+ }
+ });
+ };
+
+ vm.loadRemoteWorkFlowParameters = function (workflow) {
+ let parameters = [];
+ workflow.workflowInputParameters
+ .filter( function (param) {
+ return param.soPayloadLocation === "userParams"
+ })
+ .forEach(function (param) {
+ let workflowParams = vm.repackAttributes(param);
+ if (param.validation.length > 0) {
+ let validation = param.validation[0];
+ if ('maxLength' in validation) {
+ workflowParams.maxLength = validation.maxLength;
+ }
+ if ('allowableChars' in validation) {
+ workflowParams.pattern = validation.allowableChars;
+ }
+ }
+ workflowParams.type = param.inputType;
+
+ parameters.push(workflowParams);
+ }
+ );
+ vm.remoteWorkflowsParameters.set(workflow.name, parameters);
+ };
+
+ vm.repackAttributes = function (workflowParam){
+ return {
+ name: workflowParam.label,
+ required: workflowParam.required,
+ id: workflowParam.soFieldName,
+ soFieldName: workflowParam.soFieldName,
+ maxLength: '500',
+ pattern: '.*'
+ }
+ };
+
+ vm.getRemoteWorkFlowParameters = function (workflow) {
+ if (workflow && vm.remoteWorkflowsParameters.has(workflow)) {
+ return vm.remoteWorkflowsParameters.get(workflow)
+ }
+ return [];
+ };
+
+ vm.hasPatternError = function(form, itemName){
+ return form[itemName].$error.pattern;
+ }
+
+ vm.hasAsyncFnError = function(form, itemName){
+ return form[itemName].$error.validateAsyncFn;
+ }
+
+ vm.getIdFor = function(type, id, name){
+ return "internal-workflow-parameter-" + type + "-" + id + "-" + (name ? name.split(' ').join('-').toLowerCase() : "");
+ }
+
+ vm.getInternalWorkFlowParameters = function (workflow, type) {
+ if (workflow && vm.localWorkflowsParameters.has(workflow) && vm.localWorkflowsParameters.get(workflow).filter(parameter => parameter.type==type) != []) {
+ return vm.localWorkflowsParameters.get(workflow).filter(parameter => parameter.type==type);
+ }
+ return [];
+ };
+
+ vm.getInternalWorkFlowParameter = function (workflow, type, parameterName) {
+ if (workflow && vm.localWorkflowsParameters.has(workflow) && vm.localWorkflowsParameters.get(workflow).filter(parameter => parameter.type==type) != []) {
+ return vm.localWorkflowsParameters.get(workflow).filter(parameter => parameter.type==type).filter(parameter => parameter.name === parameterName)[0]
+ }
+ };
+
+ vm.getRemoteWorkflowSource = (workflow) => {
+ return vm.getCachedWorkflowDetails(workflow)[0].source;
+ };
+
+ vm.getCachedWorkflowDetails = function (workflow) {
+ return vm.remoteWorkflows.filter( function (remoteWorkflow) {
+ return remoteWorkflow.name === workflow;
+ });
- vm.workflows = ["Update", "Replace"];
};
//Must be $scope because we bind to the onchange of the html (cannot attached to vm variable).
vnfName[0].selectedFile = JSON.parse(lines);
} catch (error) {
$log.error(error);
+ vm.errorMsg = error;
}
};
fileReader.readAsText(file);
console.log("Will add version for selected vnf name: " + vnfName.name);
};
+ vm.isConfigUpdate = function () {
+ return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfConfigUpdate;
+ };
+
+ vm.isScaleOut = function () {
+ return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfScaleOut;
+ };
+
+ vm.shouldShowVnfInPlaceFields = function () {
+ return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfInPlace;
+ };
+
+ vm.setPreload = function (fileEl) {
+ var files = fileEl.files;
+ var file = files[0];
+ var reader = new FileReader();
+
+ reader.onloadend = function(evt) {
+ if (evt.target.readyState === FileReader.DONE) {
+ $scope.$apply(function () {
+ $scope.moduleArr[0].userParams = JSON.parse(evt.target.result);
+ });
+ }
+ };
+
+ reader.readAsText(file);
+ };
+
init();
}
})();
\ No newline at end of file