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 {
}
}
+ /**
+ * 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 =>
+ instance.originalName ? instance.originalName : this.modelUniqueId(instance);
+
+ /**
+ * 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 modeName An optional entry name (i.e. "originalName"); will not try to use as id
+ */
+ modelByIdentifiers = (serviceModelFromHierarchy, modelTypeName: string, modelUniqueNameOrId: string, modeName?: string): any => {
+ const logErrorAndReturnUndefined = () =>
+ console.info(`modelByIdentifiers: could not find a model matching query`, {
+ modelTypeName, modelUniqueNameOrId, modeName, serviceModelFromHierarchy
+ });
+
+ if (_.isNil(serviceModelFromHierarchy)) return logErrorAndReturnUndefined();
+
+ const modelsOfType = serviceModelFromHierarchy[modelTypeName];
+ if (_.isNil(modelsOfType)) return logErrorAndReturnUndefined();
+
+ const modelIfModelIdentifierIsEntryName = modelsOfType[modelUniqueNameOrId];
+ const modelIfModeNameExists = _.isNil(modeName) ? null : modelsOfType[modeName];
+
+ 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;
/**********************************************
* 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);
+ }
+ }
+
+ /****************************************************
+ * should return true if customer can upgrade a VFM *
+ ****************************************************/
+ shouldShowUpgrade(node, serviceModelId): boolean {
+ if (FeatureFlagsService.getFlagState(Features.FLAG_FLASH_REPLACE_VF_MODULE, this._store) &&
+ this.isThereAnUpdatedLatestVersion(serviceModelId)) {
+ return this.shouldShowButtonGeneric(node, VNFMethods.UPGRADE, serviceModelId);
+ }
+ else {
+ return false
+ }
+ }
+
+ private 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) {
@modelInfoService : the model (vnf, vfmodule, network, vnfgroup)object that call to the function (this)
************************************************/
openAuditInfoModal(node, serviceModelId, instance, instanceType, modelInfoService : ILevelNodeInfo){
- let isInstanceFailed = this.isFailed(node);
- AuditInfoModalComponent.openInstanceAuditInfoModal.next({
- instanceId: serviceModelId,
- type: instanceType,
- model: modelInfoService.getModel(node.data.modelName, instance, this._store.getState().service.serviceHierarchy[serviceModelId]),
- instance,
- isInstanceFailed,
- trackById: instance.trackById
- });
- }
+ AuditInfoModalComponent.openInstanceAuditInfoModal.next({
+ instanceId: serviceModelId,
+ type: instanceType,
+ model: modelInfoService.getModel(node.data.modelName, instance, this._store.getState().service.serviceHierarchy[serviceModelId]),
+ instance
+ });
+ }
+
+
+ addGeneralInfoItems(modelInfoSpecificItems: ModelInformationItem[], type: ComponentInfoType, model, instance):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),
+ ];
+ modelInfoItems = modelInfoItems.concat(modelInfoSpecificItems);
+ return this.getComponentInfoModelByModelInformationItems(modelInfoItems, type, instance);
+ }
+
+ 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
+ );
+ }
}
Code Review / vid.git / blobdiff