import {Injectable} from "@angular/core";
import {NgRedux} from "@angular-redux/store";
import {AppState} from "../../../shared/store/reducers";
-import {ServiceInstanceActions} from "../../../shared/models/serviceInstanceActions";
+import {PauseStatus, ServiceInstanceActions} from "../../../shared/models/serviceInstanceActions";
import {MessageBoxData} from "../../../shared/components/messageBox/messageBox.data";
import {MessageBoxService} from "../../../shared/components/messageBox/messageBox.service";
import * as _ from "lodash";
import {DrawingBoardModes} from "../drawing-board.modes";
import {AuditInfoModalComponent} from "../../../shared/components/auditInfoModal/auditInfoModal.component";
-import {VnfModelInfo} from "./models/vnf/vnf.model.info";
import {ILevelNodeInfo} from "./models/basic.model.info";
import {ComponentInfoModel, ComponentInfoType} from "../component-info/component-info-model";
import {ModelInformationItem} from "../../../shared/components/model-information/model-information.component";
+import {undoUpgradeService, upgradeService} from "../../../shared/storeUtil/utils/service/service.actions";
+import {VNFMethods} from "../../../shared/storeUtil/utils/vnf/vnf.actions";
+import {FeatureFlagsService, Features} from "../../../shared/services/featureFlag/feature-flags.service";
+import {Utils} from "../../../shared/utils/utils";
+import {Constants} from "../../../shared/utils/constants";
+import {NodeInstance} from "../../../shared/models/nodeInstance";
@Injectable()
export class SharedTreeService {
- private _sharedTreeService: SharedTreeService;
constructor(private _store: NgRedux<AppState>) {
}
* @param dynamicInputs - from the instance
* @param isEcompGeneratedNaming
************************************************************/
- selectedVNF: string = null;
+ selectedNF: string = null;
-
- getSelectedVNF(): string {
- return this.selectedVNF;
+ getSelectedNF(): string {
+ return this.selectedNF;
}
- setSelectedVNF(node): void {
+ setSelectedNF(node): void {
if (_.isNil(node) || node.data.type !== 'VF') {
- this.selectedVNF = null;
- } else {
- this.selectedVNF = node.data.vnfStoreKey;
+ this.selectedNF = null;
+ } else if (node.data.type === 'VF'){
+ this.selectedNF = node.data.vnfStoreKey;
+ } else if (node.data.type === 'PNF'){
+ this.selectedNF = node.data.pnfStoreKey;
}
+
}
+ /**
+ * Determines a consistent unique ID for a given right-tree
+ * node instance.
+ */
+ modelUniqueId = (nodeInstance: NodeInstance): string => {
+ return _.isNil(nodeInstance.modelInfo)
+ ? null
+ : (nodeInstance.modelInfo.modelCustomizationId || nodeInstance.modelInfo.modelInvariantId);
+ };
+
+ modelUniqueNameOrId = (instance): string => {
+ if (_.isNil(instance)) {
+ return null;
+ }
+
+ const innerInstance = _.find(instance) || {};
+
+ return instance.originalName
+ || this.modelUniqueId(instance)
+ || innerInstance.originalName
+ || this.modelUniqueId(innerInstance);
+ };
+
+ /**
+ * Finds a model inside a full service model
+ * @param serviceModelFromHierarchy
+ * @param modelTypeName "vnfs" | "networks" | "vfModules" | "collectionResources" | ...
+ * @param modelUniqueNameOrId Either an entry name (i.e. "originalName"), modelCustomizationId or modelInvariantId.
+ * Note that modelInvariantId will work only where model lacks a modelCustomizationId.
+ * @param modelName An optional entry name (i.e. "originalName"); will not try to use as id
+ */
+ modelByIdentifiers = (serviceModelFromHierarchy, modelTypeName: string, modelUniqueNameOrId: string, modelName?: string): any => {
+ const logErrorAndReturnUndefined = () =>
+ console.info(`modelByIdentifiers: could not find a model matching query`, {
+ modelTypeName, modelUniqueNameOrId, modelName, serviceModelFromHierarchy
+ });
+
+ if (_.isNil(serviceModelFromHierarchy)) return logErrorAndReturnUndefined();
+
+ const modelsOfType = serviceModelFromHierarchy[modelTypeName];
+ if (_.isNil(modelsOfType)) return logErrorAndReturnUndefined();
+
+ const modelIfModelIdentifierIsEntryName = modelsOfType[modelUniqueNameOrId];
+ const modelIfModeNameExists = _.isNil(modelName) ? null : modelsOfType[modelName];
+
+ if (!_.isNil(modelIfModelIdentifierIsEntryName)) {
+ return modelIfModelIdentifierIsEntryName;
+ } else if (!_.isNil(modelIfModeNameExists)) {
+ return modelIfModeNameExists;
+ } else {
+ // try modelUniqueNameOrId as an id
+ return _.find(modelsOfType, o => (o.customizationUuid || o.invariantUuid) === modelUniqueNameOrId) || logErrorAndReturnUndefined()
+ }
+ };
+
hasMissingData(instance, dynamicInputs: any, isEcompGeneratedNaming: boolean, requiredFields: string[]): boolean {
if (!isEcompGeneratedNaming && _.isEmpty(instance.instanceName)) {
return true;
addingStatusProperty(node) {
node['statusProperties'] = [];
- node['statusProperties'].push({key: 'Prov Status:', value: node.provStatus, testId: 'provStatus'});
- node['statusProperties'].push({key: 'Orch Status:', value: node.orchStatus, testId: 'orchStatus'});
+ node['statusProperties'].push({key: 'Prov Status: ', value: node.provStatus, testId: 'provStatus'});
+ node['statusProperties'].push({key: 'Orch Status: ', value: node.orchStatus, testId: 'orchStatus'});
+ if(node.type === 'VFmodule') {
+ node['statusProperties'].push({key: 'Model Version: ', value: this.getNodeModelVersion(node), testId: 'modelVersion'});
+ }
if (node.inMaint) {
node['statusProperties'].push({key: 'In-maintenance', value: '', testId: 'inMaint'});
}
return node;
}
+ getNodeModelVersion(node): string | undefined {
+ if(!_.isNil(node.instanceModelInfo) && !_.isNil(node.instanceModelInfo.modelVersion)){
+ return node.instanceModelInfo.modelVersion;
+ }
+ return undefined;
+ }
+
/**********************************************
* should delete or remove child instance's
"new" -> should remove
/**********************************************
* should return true if can delete
**********************************************/
- shouldShowDelete(node): boolean {
- const mode = this._store.getState().global.drawingBoardStatus;
- if (!_.isNil(node) && !_.isNil(node.data) && !_.isNil(node.data.action) && !_.isNil(node.data.menuActions['delete'])) {
- if (mode !== DrawingBoardModes.EDIT || node.data.action === ServiceInstanceActions.Create) {
- return false;
- } else if (node.data.action === ServiceInstanceActions.None) {
- return true
- }
- return false;
- }
- return false;
+ shouldShowDelete(node, serviceModelId): boolean {
+ return this.shouldShowButtonGeneric(node, "delete", serviceModelId)
}
/**********************************************
}
return false;
}
+ /**********************************************
+ * enabled only on edit/design
+ * enabled only if there's a newer version for VNF-M
+ **********************************************/
+ upgradeBottomUp(node,serviceModelId: string): void {
+ this.iterateOverTreeBranchAndRunAction(node, serviceModelId, VNFMethods.UPGRADE);
+ this._store.dispatch(upgradeService(serviceModelId));
+ }
+
+ private iterateOverTreeBranchAndRunAction(node, serviceModelId: string, actionMethod) {
+ while (_.has(node.parent, 'data') && _.has(node.parent.data, 'menuActions')
+ && !_.isNil(node.parent.data.menuActions[actionMethod])) {
+ node = node.parent;
+ node.data.menuActions[actionMethod]['method'](node, serviceModelId);
+ }
+ }
+
+ shouldShowRemovePause(node) : boolean {
+ if(FeatureFlagsService.getFlagState(Features.FLAG_2008_REMOVE_PAUSE_INSTANTIATION, this._store)){
+ return node.pauseInstantiation === PauseStatus.AFTER_COMPLETION;
+ }
+ return false;
+ }
+
+ showPauseWithOrchStatus(node): boolean {
+ if(node.orchStatus == "Active"){
+ return false;
+ }
+ return true;
+ }
+
+ shouldShowPauseInstantiation(node): boolean {
+ if(FeatureFlagsService.getFlagState(Features.FLAG_2008_REMOVE_PAUSE_INSTANTIATION, this._store)){
+ return (FeatureFlagsService.getFlagState(Features.FLAG_2006_PAUSE_VFMODULE_INSTANTIATION_CREATION, this._store) && node.pauseInstantiation == null);
+ }
+ return (FeatureFlagsService.getFlagState(Features.FLAG_2006_PAUSE_VFMODULE_INSTANTIATION_CREATION, this._store));
+ }
+ /****************************************************
+ * should return true if customer can upgrade a VFM *
+ ****************************************************/
+ shouldShowUpgrade(node, serviceModelId): boolean {
+ return (this.isVfMoudleCouldBeUpgraded(node, serviceModelId))
+ && this.shouldShowButtonGeneric(node, VNFMethods.UPGRADE, serviceModelId) ;
+ }
+
+ isVfMoudleCouldBeUpgraded(node, serviceModelId): boolean{
+ return (FeatureFlagsService.getFlagState(Features.FLAG_FLASH_REPLACE_VF_MODULE, this._store) &&
+ (this.isThereAnUpdatedLatestVersion(serviceModelId) || this.isVfModuleCustomizationIdNotExistsOnModel(node, serviceModelId)) &&
+ (this.upgradeAllowedForBm(node,serviceModelId)))
+
+
+ }
+
+ isVfModuleCustomizationIdNotExistsOnModel(vfModuleNode, serviceModelId) {
+
+ // prevent undefined
+ if (_.isNil(vfModuleNode.data) || _.isNil(vfModuleNode.data.modelCustomizationId)) {
+ return false;
+ }
+
+ let vfModulesHierarchyByGivenModelId = this._store.getState().service.serviceHierarchy[serviceModelId].vfModules;
+ return !_.some(vfModulesHierarchyByGivenModelId, vfmodel => vfmodel.customizationUuid === vfModuleNode.data.modelCustomizationId);
+ }
+
+
+ isVfmoduleAlmostPartOfModelOnlyCustomizationUuidDiffer(vfModuleNode, serviceModelId) : boolean {
+ /*
+ for `true`, should all:
+ 1. parent vnf found by model-mane
+ 2. vfmodule found by invariant
+ 3. vfmodule diff by customization
+ */
+
+ if (_.isNil(vfModuleNode.data)) {
+ return false;
+ }
+
+ const vnfHierarchy = this.getParentVnfHierarchy(vfModuleNode, serviceModelId);
+ if (_.isNil(vnfHierarchy)) {
+ return false;
+ }
+
+ const vfModuleHierarchyByInvariantId = this.getVfModuleHFromVnfHierarchyByInvariantId(vfModuleNode, vnfHierarchy);
+ if(_.isNil(vfModuleHierarchyByInvariantId)){
+ return false;
+ }
+
+ return vfModuleHierarchyByInvariantId.customizationUuid
+ && (vfModuleHierarchyByInvariantId.customizationUuid !== vfModuleNode.data.modelCustomizationId);
+ }
+
+ getParentVnfHierarchy(vfModuleNode, serviceModelId) {
+ if (vfModuleNode.parent && vfModuleNode.parent.data) {
+ return this._store.getState().service.serviceHierarchy[serviceModelId].vnfs[vfModuleNode.parent.data.modelName];
+ } else {
+ return null;
+ }
+ }
+
+ getVfModuleHFromVnfHierarchyByInvariantId(vfModuleNode, parentVnfHierarchy) {
+ if(vfModuleNode.data.modelInvariantId && parentVnfHierarchy && parentVnfHierarchy.vfModules){
+ return _.find(parentVnfHierarchy.vfModules, o => o.invariantUuid === vfModuleNode.data.modelInvariantId);
+ }
+ return null;
+ }
+
+
+ isThereAnUpdatedLatestVersion(serviceModelId) : boolean{
+ let serviceInstance = this.getServiceInstance(serviceModelId);
+ return !_.isNil(serviceInstance.latestAvailableVersion) && (Number(serviceInstance.modelInfo.modelVersion) < serviceInstance.latestAvailableVersion);
+ }
+
+ private getServiceInstance(serviceModelId): any {
+ return this._store.getState().service.serviceInstance[serviceModelId];
+ }
+
+ shouldShowButtonGeneric(node, method, serviceModelId) {
+ const mode = this._store.getState().global.drawingBoardStatus;
+ const isMacro = !(this.getServiceInstance(serviceModelId).isALaCarte);
+
+ if (isMacro) { //if macro action allowed only for service level
+ return false;
+ }
+
+ if (!_.isNil(node) && !_.isNil(node.data) && !_.isNil(node.data.action) && !_.isNil(node.data.menuActions[method])) {
+ if (mode !== DrawingBoardModes.EDIT || node.data.action === ServiceInstanceActions.Create) {
+ return false;
+ }
+ else if (node.data.action === ServiceInstanceActions.None) {
+ return true
+ }
+ }
+ return false;
+ }
+
+ /**********************************************
+ * return boolean according to
+ * current defined action of VFModule node
+ **********************************************/
+ shouldShowUndoUpgrade(node): boolean {
+ const mode = this._store.getState().global.drawingBoardStatus;
+ if (mode === DrawingBoardModes.EDIT && !_.isNil(node.data.action) && !_.isNil(node.data.menuActions[VNFMethods.UNDO_UPGRADE])) {
+ if (node.data.action === ServiceInstanceActions.Upgrade) {
+ return false;
+ } else if (node.data.action.split('_').pop() === ServiceInstanceActions.Upgrade) {
+ return true
+ }
+ return false;
+ }
+ return false;
+ }
+ /**********************************************
+ * enabled only on edit/design
+ * enabled only if there's a newer version for VNF-M
+ **********************************************/
+ undoUpgradeBottomUp(node,serviceModelId: string): void {
+ this.iterateOverTreeBranchAndRunAction(node, serviceModelId, VNFMethods.UNDO_UPGRADE);
+ this._store.dispatch(undoUpgradeService(serviceModelId));
+ }
/**********************************************
* should return true if can duplicate by mode
**********************************************/
**********************************************/
shouldShowAddIcon(): boolean{
const mode = this._store.getState().global.drawingBoardStatus;
- return mode === DrawingBoardModes.EDIT || mode=== DrawingBoardModes.CREATE;
+ return mode === DrawingBoardModes.EDIT || mode=== DrawingBoardModes.CREATE || mode=== DrawingBoardModes.RECREATE;
+ }
+
+
+ isReachedToMaxInstances(properties, counter, flags): boolean{
+ let maxInstances = Utils.getMaxFirstLevel(properties, flags);
+ if(_.isNil(maxInstances)){
+ return false;
+ }else {
+ return !(maxInstances > counter);
+ }
}
/************************************************
return number of instances with action Delete
************************************************/
getExistingInstancesWithDeleteMode(node, serviceModelId: string, type: string): number {
let counter = 0;
- const existingInstances = this._store.getState().service.serviceInstance[serviceModelId][type];
+ const existingInstances = this.getServiceInstance(serviceModelId)[type];
const modelUniqueId = node.data.modelUniqueId;
if (!_.isNil(existingInstances)) {
for (let instanceKey in existingInstances) {
AuditInfoModalComponent.openInstanceAuditInfoModal.next({
instanceId: serviceModelId,
type: instanceType,
- model: modelInfoService.getModel(node.data.modelName, instance, this._store.getState().service.serviceHierarchy[serviceModelId]),
+ model: modelInfoService.getModel(
+ this.modelByIdentifiers(
+ this._store.getState().service.serviceHierarchy[serviceModelId],
+ modelInfoService.name,
+ this.modelUniqueNameOrId(instance), node.data.modelName
+ )
+ ),
instance
});
}
+ getModelVersionEitherFromInstanceOrFromHierarchy(selectedNodeData, model): string | undefined {
+ return this.getNamedFieldFromInstanceOrFromHierarchy(selectedNodeData, "modelVersion", model, "version");
+ }
+
+ getModelCustomizationIdEitherFromInstanceOrFromHierarchy(selectedNodeData, model): string | undefined {
+ return this.getNamedFieldFromInstanceOrFromHierarchy(selectedNodeData, "modelCustomizationId", model, "customizationUuid");
+ }
+
+ getModelInvariantIdEitherFromInstanceOrFromHierarchy(selectedNodeData, model): string | undefined {
+ return this.getNamedFieldFromInstanceOrFromHierarchy(selectedNodeData, "modelInvariantId", model, "invariantUuid");
+ }
- addGeneralInfoItems(modelInfoSpecificItems: ModelInformationItem[], type: ComponentInfoType, model, instance):ComponentInfoModel {
+ getModelVersionIdEitherFromInstanceOrFromHierarchy(selectedNodeData, model): string | undefined {
+ return this.getNamedFieldFromInstanceOrFromHierarchy (selectedNodeData, "modelVersionId", model, "uuid");
+ }
+
+
+
+ getNamedFieldFromInstanceOrFromHierarchy(selectedNodeData, instanceModelInfoFieldName, model, modelFieldName): string | undefined {
+ if (instanceModelInfoFieldName && selectedNodeData && selectedNodeData.instanceModelInfo
+ && selectedNodeData.instanceModelInfo[instanceModelInfoFieldName]) {
+ return selectedNodeData.instanceModelInfo[instanceModelInfoFieldName];
+ } else if (modelFieldName && model && model[modelFieldName]) {
+ return model[modelFieldName];
+ }
+ return undefined;
+ }
+
+ addGeneralInfoItems(modelInfoSpecificItems: ModelInformationItem[], type: ComponentInfoType, model, selectedNodeData):ComponentInfoModel {
let modelInfoItems: ModelInformationItem[] = [
- ModelInformationItem.createInstance("Model version", model ? model.version : null),
- ModelInformationItem.createInstance("Model customization ID", model ? model.customizationUuid : null),
- ModelInformationItem.createInstance("Instance ID", instance ? instance.instanceId : null),
- ModelInformationItem.createInstance("Instance type", instance ? instance.instanceType : null),
- ModelInformationItem.createInstance("In maintenance", instance? instance.inMaint : null),
+ ModelInformationItem.createInstance("Model version", this.getModelVersionEitherFromInstanceOrFromHierarchy(selectedNodeData, model)),
+ ModelInformationItem.createInstance("Model customization ID", this.getModelCustomizationIdEitherFromInstanceOrFromHierarchy(selectedNodeData, model)),
+ ModelInformationItem.createInstance("Instance ID", selectedNodeData ? selectedNodeData.instanceId : null),
+ ModelInformationItem.createInstance("Instance type", selectedNodeData ? selectedNodeData.instanceType : null),
+ ModelInformationItem.createInstance("In maintenance", selectedNodeData? selectedNodeData.inMaint : null),
];
modelInfoItems = modelInfoItems.concat(modelInfoSpecificItems);
- return this.getComponentInfoModelByModelInformationItems(modelInfoItems, type, instance);
+ return this.getComponentInfoModelByModelInformationItems(modelInfoItems, type, selectedNodeData);
}
getComponentInfoModelByModelInformationItems(modelInfoItems: ModelInformationItem[], type: ComponentInfoType, instance){
const modelInfoItemsWithoutEmpty = _.filter(modelInfoItems, function(item){ return !item.values.every(_.isNil)});
return new ComponentInfoModel(type, modelInfoItemsWithoutEmpty, [], instance != null);
}
+
+ createMaximumToInstantiateModelInformationItem(model): ModelInformationItem {
+ return ModelInformationItem.createInstance(
+ "Max instances",
+ !_.isNil(model.max) ? String(model.max) : Constants.ModelInfo.UNLIMITED_DEFAULT
+ );
+ }
+
+ isAddPositionFlagTrue():boolean{
+ return FeatureFlagsService.getFlagState(Features.FLAG_2008_CREATE_VFMODULE_INSTANTIATION_ORDER_NUMBER, this._store);
+ }
+
+ upgradeAllowedForBm(node, serviceModelId):boolean {
+
+ if(FeatureFlagsService.getFlagState(Features.FLAG_2012_UPGRADE_BASE_MODULE_FLAG, this._store)){
+ let returnValue = false;
+ if(node.data.type == 'VFmodule') {
+ let serviceHierarchy = this._store.getState().service.serviceHierarchy[serviceModelId];
+ let vnf = node.parent.data.modelName;
+ let baseModuleFlag= (serviceHierarchy.vnfs[vnf].vfModules[node.data.modelName].properties.baseModule) ? true: false;
+
+ if(baseModuleFlag) {
+ if(node.parent.children.length >1) {
+ return returnValue;
+ }
+ else {
+ returnValue = true;
+ }
+ }else {
+ returnValue = true;
+ }
+
+ } else {
+ returnValue= true
+ }
+
+ return returnValue;
+ } else {
+ return true;
+ }
+ }
}