import {AvailableNodeIcons} from "../../../available-models-tree/available-models-tree.service";
import {IframeService} from "../../../../../shared/utils/iframe.service";
import {
- deleteActionVfModuleInstance,
+ deleteActionVfModuleInstance, deleteVFModuleField,
removeVfModuleInstance,
undoDeleteVfModuleInstance,
- updateVFModulePosition
+ undoUgradeVFModule, updateVFModuleField,
+ updateVFModulePosition,
+ upgradeVFModule
} from "../../../../../shared/storeUtil/utils/vfModule/vfModule.actions";
import {ComponentInfoService} from "../../../component-info/component-info.service";
-import {ComponentInfoModel, ComponentInfoType} from "../../../component-info/component-info-model";
+import {ComponentInfoType} from "../../../component-info/component-info-model";
import {ModelInformationItem} from "../../../../../shared/components/model-information/model-information.component";
+import {VfModuleUpgradePopupService} from "../../../../../shared/components/genericFormPopup/genericFormServices/vfModuleUpgrade/vfModule.upgrade.popuop.service";
+import {FeatureFlagsService, Features} from "../../../../../shared/services/featureFlag/feature-flags.service";
export class VFModuleModelInfo implements ILevelNodeInfo {
constructor(private _dynamicInputsService: DynamicInputsService,
private _sharedTreeService: SharedTreeService,
private _dialogService: DialogService,
private _vfModulePopupService: VfModulePopuopService,
+ private _vfModuleUpgradePopupService: VfModuleUpgradePopupService,
private _iframeService: IframeService,
+ private _featureFlagsService: FeatureFlagsService,
private _store: NgRedux<AppState>,
private _componentInfoService: ComponentInfoService) {
}
name: string = 'vfModules';
type: string = 'Module';
typeName: string = 'M';
+ componentInfoType = ComponentInfoType.VFMODULE;
/***********************************************************
* return if user should provide instance name or not.
newVfModule.typeName = this.typeName;
newVfModule.menuActions = this.getMenuAction(<any>newVfModule, currentModel.uuid);
newVfModule.isFailed = _.isNil(instance.isFailed) ? false : instance.isFailed;
- newVfModule.statusMessage = !_.isNil(instance.statusMessage) ? instance.statusMessage: "";
+ newVfModule.statusMessage = !_.isNil(instance.statusMessage) ? instance.statusMessage : "";
newVfModule = this._sharedTreeService.addingStatusProperty(newVfModule);
return newVfModule;
if (!_.isNil(this._store.getState().service.serviceInstance[serviceModelId].vnfs[selectedVNF]) && node.parent.data.name === this._store.getState().service.serviceInstance[serviceModelId].vnfs[selectedVNF].originalName) {
const existingVFModules = this.getCountVFModuleOfSelectedVNF(node, selectedVNF, serviceModelId);
const reachedLimit = this.isVFModuleReachedLimit(node, this._store.getState().service.serviceHierarchy, serviceModelId, existingVFModules);
- const showAddIcon = this._sharedTreeService.shouldShowAddIcon()&& !reachedLimit;
+ const showAddIcon = this._sharedTreeService.shouldShowAddIcon() && !reachedLimit;
return new AvailableNodeIcons(showAddIcon, reachedLimit);
}
return new AvailableNodeIcons(false, false);
maxNodes = vnfModules[node.data.name].properties.maxCountInstances || 1;
}
return !(maxNodes > currentNodeCount);
-
}
getMenuAction(node: ITreeNode, serviceModelId: string): { [methodName: string]: { method: Function, visible: Function, enable: Function } } {
},
undoDelete: {
method: (node, serviceModelId) => {
- this._store.dispatch(undoDeleteVfModuleInstance(node.data.dynamicModelName, node.parent.data.vnfStoreKey, serviceModelId))
+ this._store.dispatch(undoDeleteVfModuleInstance(node.data.dynamicModelName, node.parent.data.vnfStoreKey, serviceModelId));
+ this._store.dispatch(deleteVFModuleField(node.data.modelName, node.parent.data.vnfStoreKey, node.data.servicedId ,node.data.dynamicModelName, 'retainAssignments'));
},
visible: (node) => this._sharedTreeService.shouldShowUndoDelete(node),
enable: (node, serviceModelId) => this._sharedTreeService.shouldShowUndoDelete(node) && this._sharedTreeService.shouldShowDelete(node.parent) && !this._sharedTreeService.isServiceOnDeleteMode(serviceModelId)
- }
+ },
+ upgrade: {
+ method: (node, serviceModelId) => {
+ this.upgradeVFM(serviceModelId, node);
+ },
+ visible: (node,serviceModelId) => {
+ return this._sharedTreeService.shouldShowUpgrade(node, serviceModelId);
+ },
+ enable: (node, serviceModelId) => {
+ return this._sharedTreeService.shouldShowUpgrade(node, serviceModelId);
+ }
+ },
+ undoUpgrade: {
+ method: (node, serviceModelId) => {
+ this._sharedTreeService.undoUpgradeBottomUp(node, serviceModelId);
+ this._store.dispatch(undoUgradeVFModule(node.data.modelName, node.parent.data.vnfStoreKey, serviceModelId, node.data.dynamicModelName));
+ },
+ visible: (node) => {
+ return this._sharedTreeService.shouldShowUndoUpgrade(node);
+ },
+ enable: (node) => {
+ return this._sharedTreeService.shouldShowUndoUpgrade(node);
+ }
+ },
};
+ }
-
+ private upgradeVFM(serviceModelId, node) {
+ if (FeatureFlagsService.getFlagState(Features.FLAG_2002_VFM_UPGRADE_ADDITIONAL_OPTIONS, this._store)) {
+ this._iframeService.addClassOpenModal('content');
+ this._dialogService.addDialog(GenericFormPopupComponent, {
+ type: PopupType.VF_MODULE_UPGRADE,
+ uuidData: <any>{
+ serviceId: serviceModelId,
+ modelName: node.data.modelName,
+ vFModuleStoreKey: node.data.dynamicModelName,
+ vnfStoreKey: node.parent.data.vnfStoreKey,
+ modelId: node.data.modelId,
+ type: node.data.type,
+ popupService: this._vfModuleUpgradePopupService,
+ vfModule : _.cloneDeep(node)
+ },
+ node,
+ isUpdateMode: false
+ });
+ }else {
+ this._sharedTreeService.upgradeBottomUp(node, serviceModelId);
+ this._store.dispatch(upgradeVFModule(node.data.modelName, node.parent.data.vnfStoreKey, serviceModelId ,node.data.dynamicModelName));
+ }
}
- updatePosition(that , node, instanceId, parentStoreKey): void {
+ updatePosition(that, node, instanceId, parentStoreKey): void {
that.store.dispatch(updateVFModulePosition(node, instanceId, parentStoreKey));
}
return (!_.isNil(instance) && !_.isNil(instance[deepDynamicName])) ? instance[deepDynamicName].position : null;
}
- onSelectedNode(node: ITreeNode): void {
+ getInfo(model, instance): ModelInformationItem[] {
+ const modelInformation = !_.isEmpty(model) && !_.isEmpty(model.properties) ? [
+ ModelInformationItem.createInstance("Base module", model.properties.baseModule),
+ ModelInformationItem.createInstance("Min instances", !_.isNull(model.properties.minCountInstances) ? String(model.properties.minCountInstances) : null),
+ ModelInformationItem.createInstance("Max instances", !_.isNull(model.properties.maxCountInstances) ? String(model.properties.maxCountInstances) : null),
+ ModelInformationItem.createInstance("Initial instances count", !_.isNull(model.properties.initialCount) ? String(model.properties.initialCount) : null)
+ ] : [];
+
+ const instanceInfo = [];
+ const result = [modelInformation, instanceInfo];
+ return _.uniq(_.flatten(result));
}
-
- getInfoForVFModule(model, instance): ComponentInfoModel {
- let modelInfoItems: ModelInformationItem[] = [];
- if (model && !_.isNil(model.properties))
- {
- modelInfoItems = [
- ModelInformationItem.createInstance("Base Module", model.properties.baseModule),
- ModelInformationItem.createInstance("Min Instances", model.properties.minCountInstances),
- ModelInformationItem.createInstance("Max Instances", model.properties.maxCountInstances),
- ModelInformationItem.createInstance("Initial Instances Count", model.properties.initialCount)
- ];
- }
- return this._componentInfoService.addGeneralInfoItems(modelInfoItems, ComponentInfoType.VFMODULE, model, instance);
- }
-
-
}