vid-webpack-master/src/app/drawingBoard/service-planning/objectsToTree/models/pnf/pnf.model.info.extended.ts

   1 import {ILevelNodeInfo} from "../basic.model.info";
   2 import {ComponentInfoType} from "../../../component-info/component-info-model";
   3 import {ModelInformationItem} from "../../../../../shared/components/model-information/model-information.component";
   4 import {ITreeNode} from "angular-tree-component/dist/defs/api";
   5 import {AvailableNodeIcons} from "../../../available-models-tree/available-models-tree.service";
   6 import {PNFModel} from "../../../../../shared/models/pnfModel";
   7 import {SharedTreeService} from "../../shared.tree.service";
   8 import * as _ from "lodash";
   9 import {FeatureFlagsService} from "../../../../../shared/services/featureFlag/feature-flags.service";
  10 import {NgRedux} from "@angular-redux/store";
  11 import {AppState} from "../../../../../shared/store/reducers";
  12 import {
  13   GenericFormPopupComponent,
  14   PopupType
  15 } from "../../../../../shared/components/genericFormPopup/generic-form-popup.component";
  16 import {DialogService} from "ng2-bootstrap-modal";
  17 import {PnfPopupService} from "../../../../../shared/components/genericFormPopup/genericFormServices/pnf/pnf.popup.service";
  18 import {PnfTreeNode} from "../../../../../shared/models/pnfTreeNode";
  19 import {changeInstanceCounter, removeInstance} from "../../../../../shared/storeUtil/utils/general/general.actions";
  20 import {MessageBoxData} from "../../../../../shared/components/messageBox/messageBox.data";
  21 import {MessageBoxService} from "../../../../../shared/components/messageBox/messageBox.service";
  22 import {IframeService} from "../../../../../shared/utils/iframe.service";
  23 import {DuplicateService} from "../../../duplicate/duplicate.service";
  24 import {ModalService} from "../../../../../shared/components/customModal/services/modal.service";
  25 import {
  26   deleteActionPnfInstance,
  27   undoDeleteActionPnfInstance,
  28   updatePnfPosition
  29 } from "../../../../../shared/storeUtil/utils/pnf/pnf.actions";
  30 import {DynamicInputsService} from "../../dynamicInputs.service";
  31 import {InputType} from "../../../../../shared/models/inputTypes";
  32
  33 export class PnfModelInfoExtended implements ILevelNodeInfo {
  34
  35   constructor(
  36     private _store: NgRedux<AppState>,
  37     private _sharedTreeService: SharedTreeService,
  38     private _dialogService: DialogService,
  39     private _pnfPopupService: PnfPopupService,
  40     private _iframeService: IframeService,
  41     private _duplicateService: DuplicateService,
  42     private modalService: ModalService,
  43     private _dynamicInputsService: DynamicInputsService
  44   ) {}
  45
  46   name: string = 'pnfs';
  47   type: string = 'PNF';
  48   typeName: string = 'PNF';
  49   childNames: string[];
  50   componentInfoType = ComponentInfoType.PNF;
  51
  52   createInstanceTreeNode = (instance: any, model: any, parentModel: any, storeKey: string, serviceModelId: string): any => {
  53     let node = new PnfTreeNode(instance, model, storeKey);
  54     node.missingData = this.hasMissingData(instance, node, model.isEcompGeneratedNaming);
  55     node.typeName = this.typeName;
  56     node.menuActions = this.getMenuAction(<any>node, serviceModelId);
  57     node.isFailed = _.isNil(instance.isFailed) ? false : instance.isFailed;
  58     node.statusMessage = !_.isNil(instance.statusMessage) ? instance.statusMessage : "";
  59     node = this._sharedTreeService.addingStatusProperty(node);
  60     return node;
  61   };
  62
  63   getInfo(model, instance): ModelInformationItem[] {
  64     const modelInformation = !_.isEmpty(model) ? [
  65       ModelInformationItem.createInstance("Min instances", !_.isNil(model.min) ? String(model.min) : null),
  66       this._sharedTreeService.createMaximumToInstantiateModelInformationItem(model)
  67     ] : [];
  68
  69     const instanceInfo = !_.isEmpty(instance) ? [
  70       ModelInformationItem.createInstance("NF type", instance.nfType),
  71       ModelInformationItem.createInstance("NF role", instance.nfRole)
  72     ] : [];
  73
  74     const result = [modelInformation, instanceInfo];
  75     return _.uniq(_.flatten(result));
  76   }
  77
  78   getMenuAction(node: ITreeNode, serviceModelId: string): { [methodName: string]: { method: Function, visible: Function, enable: Function } } {
  79     return <any>{
  80       edit: {
  81         method: (node, serviceModelId) => {
  82           this._iframeService.addClassOpenModal('content');
  83           this._dialogService.addDialog(GenericFormPopupComponent, {
  84             type: PopupType.PNF,
  85             uuidData: <any>{
  86               serviceId: serviceModelId,
  87               modelName: node.data.modelName,
  88               pnfStoreKey: node.data.pnfStoreKey,
  89               modelId: node.data.modelId,
  90               type: node.data.type,
  91               popupService: this._pnfPopupService
  92             },
  93             node: node,
  94             isUpdateMode: true
  95           });
  96         },
  97         visible: (node) => this._sharedTreeService.shouldShowRemoveAndEdit(node),
  98         enable: (node) => this._sharedTreeService.shouldShowRemoveAndEdit(node),
  99       },
 100       showAuditInfo: {
 101         method: (node, serviceModelId) => {
 102           const instance = this._store.getState().service.serviceInstance[serviceModelId].pnfs[node.data.pnfStoreKey];
 103           this._sharedTreeService.openAuditInfoModal(node, serviceModelId, instance, 'PNF', this);
 104         },
 105         visible: (node) => this._sharedTreeService.shouldShowAuditInfo(node),
 106         enable: (node) => this._sharedTreeService.shouldShowAuditInfo(node)
 107       },
 108       remove: {
 109         method: (node, serviceModelId) => {
 110           if ((!_.isNil(node.data.children) && node.data.children.length === 0) || _.isNil(node.data.children)) {
 111             let storeKey: string = node.data.pnfStoreKey;
 112             this._store.dispatch(removeInstance(node.data.pnfStoreKey, serviceModelId, storeKey, node));
 113             this._store.dispatch(changeInstanceCounter(node.data.modelUniqueId, serviceModelId, -1, node));
 114             this._sharedTreeService.selectedNF = null;
 115           } else {
 116             let messageBoxData: MessageBoxData = new MessageBoxData(
 117               "Remove PNF",  // modal title
 118               "You are about to remove this PNF from this service. Are you sure you want to remove it?",
 119               <any>"warning",
 120               <any>"md",
 121               [
 122                 {
 123                   text: "Remove PNF",
 124                   size: "large",
 125                   callback: this.removePnf.bind(this, node, serviceModelId),
 126                   closeModal: true
 127                 },
 128                 {text: "Don’t Remove", size: "medium", closeModal: true}
 129               ]);
 130
 131             MessageBoxService.openModal.next(messageBoxData);
 132           }
 133         },
 134         visible: (node) => this._sharedTreeService.shouldShowRemoveAndEdit(node),
 135         enable: (node) => this._sharedTreeService.shouldShowRemoveAndEdit(node),
 136       },
 137       delete: {
 138         method: (node, serviceModelId) => {
 139           if ((!_.isNil(node.data.children) && node.data.children.length === 0) || _.isNil(node.data.children)) {
 140             this._store.dispatch(deleteActionPnfInstance(node.data.pnfStoreKey, serviceModelId));
 141           } else {
 142             this._sharedTreeService.shouldShowDeleteInstanceWithChildrenModal(node, serviceModelId, (node, serviceModelId) => {
 143               this._sharedTreeService.removeDeleteAllChild(node, serviceModelId, (node, serviceModelId) => {
 144                 this._store.dispatch(deleteActionPnfInstance(node.data.pnfStoreKey, serviceModelId));
 145               });
 146             });
 147           }
 148         },
 149         visible: (node) => this._sharedTreeService.shouldShowDelete(node, serviceModelId),
 150         enable: (node) => this._sharedTreeService.shouldShowDelete(node, serviceModelId)
 151       },
 152       undoDelete: {
 153         method: (node, serviceModelId) => {
 154           if ((!_.isNil(node.data.children) && node.data.children.length === 0) || _.isNil(node.data.children)) {
 155             this._store.dispatch(undoDeleteActionPnfInstance(node.data.pnfStoreKey, serviceModelId));
 156           } else {
 157             this._sharedTreeService.undoDeleteAllChild(node, serviceModelId, (node, serviceModelId) => {
 158               this._store.dispatch(undoDeleteActionPnfInstance(node.data.pnfStoreKey, serviceModelId));
 159             });
 160           }
 161         },
 162         visible: (node) => this._sharedTreeService.shouldShowUndoDelete(node),
 163         enable: (node, serviceModelId) => this._sharedTreeService.shouldShowUndoDelete(node) && !this._sharedTreeService.isServiceOnDeleteMode(serviceModelId)
 164       }
 165     }
 166   }
 167
 168   removePnf(this, node, serviceModelId) {
 169     this._store.dispatch(removeInstance(node.data.modelName, serviceModelId, node.data.pnfStoreKey, node));
 170     this._store.dispatch(changeInstanceCounter(node.data.modelUniqueId, serviceModelId, -1, node));
 171     this._sharedTreeService.selectedNF = null;
 172   }
 173
 174   getModel = (instanceModel: any): PNFModel => {
 175     return new PNFModel(instanceModel);
 176   };
 177
 178   getNextLevelObject(): any {
 179     return null;
 180   }
 181
 182   getNodeCount(node: ITreeNode, serviceModelId: string): number {
 183     let map = null;
 184     if (!_.isNil(this._store.getState().service.serviceInstance[serviceModelId])) {
 185       map = this._store.getState().service.serviceInstance[serviceModelId].existingPNFCounterMap || 0;
 186
 187       if (!_.isNil(map)) {
 188         let count = map[node.data.modelUniqueId] || 0;
 189         count -= this._sharedTreeService.getExistingInstancesWithDeleteMode(node, serviceModelId, 'pnfs');
 190         return count;
 191       }
 192     }
 193     return 0;
 194   }
 195
 196   getNodePosition(instance): number {
 197     return !_.isNil(instance) ? instance.position : null;
 198   }
 199
 200   getTooltip = (): string => 'PNF';
 201
 202   getType = (): string => 'PNF';
 203
 204   hasMissingData(instance, dynamicInputs: any, isEcompGeneratedNaming: boolean): boolean {
 205     return this._sharedTreeService.hasMissingData(instance, dynamicInputs, isEcompGeneratedNaming, [InputType.PLATFORM]);
 206   }
 207
 208   /***********************************************************
 209    * return if user should provide instance name or not.
 210    * @param currentModel - current Model object
 211    ************************************************************/
 212   isEcompGeneratedNaming = (currentModel): boolean => {
 213     const ecompGeneratedNaming = currentModel.properties.ecomp_generated_naming;
 214     return ecompGeneratedNaming === "true";
 215   };
 216
 217   onClickAdd(node, serviceModelId: string): void {
 218     this._dialogService.addDialog(GenericFormPopupComponent, {
 219       type: PopupType.PNF,
 220       uuidData: <any>{
 221         serviceId: serviceModelId,
 222         modelName: node.data.name,
 223         pnfStoreKey: null,
 224         modelId: node.data.modelVersionId,
 225         type: node.data.type,
 226         popupService: this._pnfPopupService
 227       },
 228       node: node,
 229       isUpdateMode: false
 230     })
 231   }
 232
 233   showNodeIcons(node: ITreeNode, serviceModelId: string): AvailableNodeIcons {
 234     let counter: number = !_.isNil(this._store.getState().service.serviceInstance[serviceModelId]) ?
 235       (this._store.getState().service.serviceInstance[serviceModelId].existingPNFCounterMap[node.data.modelUniqueId] || 0) : 0;
 236     counter -= this._sharedTreeService.getExistingInstancesWithDeleteMode(node, serviceModelId, 'pnfs');
 237
 238     const properties = this._store.getState().service.serviceHierarchy[serviceModelId].pnfs[node.data.name].properties;
 239     const flags = FeatureFlagsService.getAllFlags(this._store);
 240     const isReachedLimit: boolean = this._sharedTreeService.isReachedToMaxInstances(properties, counter, flags);
 241     const showAddIcon = this._sharedTreeService.shouldShowAddIcon() && !isReachedLimit;
 242     return new AvailableNodeIcons(showAddIcon, isReachedLimit)
 243   }
 244
 245   updateDynamicInputsDataFromModel = (currentModel): any => {
 246     let displayInputs = _.isNil(currentModel) ? [] : currentModel.inputs;
 247     return _.isEmpty(displayInputs) ? [] : this._dynamicInputsService.getArbitraryInputs(displayInputs);
 248   };
 249
 250   updatePosition(that, node, instanceId): void {
 251     that.store.dispatch(updatePnfPosition(node, instanceId, node.vnfStoreKey));
 252   }
 253 }