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

   1 import {ILevelNodeInfo} from "../basic.model.info";
   2 import {ComponentInfoType} from "../../../component-info/component-info-model";
   3 import {ITreeNode} from "angular-tree-component/dist/defs/api";
   4 import {AvailableNodeIcons} from "../../../available-models-tree/available-models-tree.service";
   5 import {ModelInformationItem} from "../../../../../shared/components/model-information/model-information.component";
   6 import {VrfTreeNode} from "../../../../../shared/models/vrfTreeNode";
   7 import {VrfModel} from "../../../../../shared/models/vrfModel";
   8 import {NgRedux} from "@angular-redux/store";
   9 import {AppState} from "../../../../../shared/store/reducers";
  10 import {SharedTreeService} from "../../shared.tree.service";
  11 import {DialogService} from 'ng2-bootstrap-modal';
  12 import {SearchElementsModalComponent} from "../../../../../shared/components/searchMembersModal/search-elements-modal.component";
  13 import {IframeService} from "../../../../../shared/utils/iframe.service";
  14 import {NetworkStepService} from "./vrfModal/networkStep/network.step.service";
  15 import {VpnStepService} from "./vrfModal/vpnStep/vpn.step.service";
  16 import {NetworkModelInfo} from "../network/network.model.info";
  17 import {VpnModelInfo} from "../vpn/vpn.model.info";
  18 import {
  19   clearAllGenericModalhelper,
  20   updateGenericModalhelper,
  21   updateGenericModalTableDataHelper
  22 } from "../../../../../shared/storeUtil/utils/global/global.actions";
  23 import {
  24   deleteActionVrfInstance,
  25   undoDeleteActionVrfInstance
  26 } from "../../../../../shared/storeUtil/utils/vrf/vrf.actions";
  27 import * as _ from "lodash";
  28 import {FeatureFlagsService} from "../../../../../shared/services/featureFlag/feature-flags.service";
  29
  30 export class VrfModelInfo implements ILevelNodeInfo {
  31   constructor(private _store: NgRedux<AppState>,
  32               private _sharedTreeService: SharedTreeService,
  33               private _dialogService: DialogService,
  34               private _iframeService: IframeService,
  35               private _featureFlagsService : FeatureFlagsService,
  36               private _networkStepService: NetworkStepService,
  37               private _vpnStepService: VpnStepService) {
  38   }
  39
  40   name: string = 'vrfs';
  41   type: string = 'VRF';
  42   typeName: string = 'VRF';
  43   childNames: string [] = ["networks", "vpns"];
  44   componentInfoType = ComponentInfoType.VRF;
  45
  46   isEcompGeneratedNaming(currentModel): boolean {
  47     return false;
  48   }
  49
  50   updateDynamicInputsDataFromModel = (currentModel): any => [];
  51
  52   getModel = (instanceModel: any): VrfModel => {
  53     return new VrfModel(instanceModel);
  54   };
  55
  56
  57   createInstanceTreeNode = (instance: any, model: any, parentModel: any, storeKey: string, serviceModelId: string): any => {
  58     let node = new VrfTreeNode(instance, model, storeKey);
  59     node.missingData = this.hasMissingData(instance, node, model.isEcompGeneratedNaming);
  60     node.typeName = this.typeName;
  61     node.menuActions = this.getMenuAction(<any>node, serviceModelId);
  62     node.isFailed = _.isNil(instance.isFailed) ? false : instance.isFailed;
  63     node.statusMessage = !_.isNil(instance.statusMessage) ? instance.statusMessage : "";
  64     return node;
  65   };
  66
  67
  68   getNextLevelObject = (nextLevelType: string): any => {
  69     if (nextLevelType === 'vpns') {
  70       return new VpnModelInfo(this._store, this._sharedTreeService);
  71     } else {
  72       if (nextLevelType === 'networks') {
  73         return new NetworkModelInfo(null, this._sharedTreeService, null, null, null, null, null,this._featureFlagsService,  this._store);
  74       }
  75     }
  76   };
  77
  78   getTooltip = (): string => 'VRF';
  79
  80   getType = (): string => 'VRF';
  81
  82   hasMissingData(instance, dynamicInputs: any, isEcompGeneratedNaming: boolean): boolean {
  83     return false;
  84   }
  85
  86   onClickAdd(node, serviceModelId: string): void {
  87     this._store.dispatch(clearAllGenericModalhelper());
  88     this._store.dispatch(updateGenericModalTableDataHelper('currentVRF', {
  89       model: this._store.getState().service.serviceHierarchy[serviceModelId].vrfs[node.data.name],
  90       instance: null
  91     }));
  92     this._iframeService.addFullScreen();
  93     let modalSteps = [this._vpnStepService, this._networkStepService];
  94     const serviceInstance = this._store.getState().service.serviceInstance[serviceModelId];
  95     this._dialogService.addDialog(SearchElementsModalComponent, {
  96         modalInformation: this._networkStepService.getNetworkStep(serviceInstance, serviceModelId, ...modalSteps)
  97       }
  98     )
  99   }
 100
 101   getNodeCount(node: ITreeNode, serviceModelId: string): number {
 102     //TODO
 103     return 0;
 104   }
 105
 106   showNodeIcons(node: ITreeNode, serviceModelId: string): AvailableNodeIcons {
 107     const serviceHierarchy = this._store.getState().service.serviceHierarchy[serviceModelId];
 108
 109     let counter: number = !_.isNil(this._store.getState().service.serviceInstance[serviceModelId]) ?
 110       (this._store.getState().service.serviceInstance[serviceModelId].existingVRFCounterMap[node.data.modelUniqueId] || 0) : 0;
 111     counter -= this._sharedTreeService.getExistingInstancesWithDeleteMode(node, serviceModelId, 'vrfs');
 112
 113     const instanceModel = this._sharedTreeService.modelByIdentifiers(
 114       serviceHierarchy, node.data.modelTypeName,
 115       this._sharedTreeService.modelUniqueNameOrId(node.data), node.data.name
 116     );
 117
 118     const model = node.data.getModel(instanceModel);
 119     const maxInstances: number = model.max;
 120     const isReachedLimit = !(maxInstances > counter);
 121     const showAddIcon = this._sharedTreeService.shouldShowAddIcon() && !isReachedLimit;
 122
 123     return new AvailableNodeIcons(showAddIcon, isReachedLimit)
 124   }
 125
 126   getMenuAction(node: ITreeNode, serviceModelId: string): { [methodName: string]: { method: Function, visible: Function, enable: Function } } {
 127     return <any>{
 128       changeAssociations: {
 129         method: (node, serviceModelId) => {
 130           let modalSteps = [this._vpnStepService, this._networkStepService];
 131           this._store.dispatch(clearAllGenericModalhelper());
 132           const vrfInstance = this._store.getState().service.serviceInstance[serviceModelId].vrfs[node.data.vrfStoreKey];
 133           const vrfModel = this._store.getState().service.serviceHierarchy[serviceModelId].vrfs[node.data.name];
 134           this._store.dispatch(updateGenericModalTableDataHelper('currentVRF', {
 135             model: vrfModel,
 136             instance: vrfInstance,
 137             vrfStoreKey: node.data.vrfStoreKey
 138           }));
 139
 140
 141           for (let networkKey in vrfInstance.networks) {
 142             this._store.dispatch(updateGenericModalhelper(`selectedNetwork`, vrfInstance.networks[networkKey], modalSteps[1].uniqObjectField));
 143           }
 144
 145           for (let networkKey in vrfInstance.vpns) {
 146             this._store.dispatch(updateGenericModalhelper(`selectedVPN`, vrfInstance.vpns[networkKey], modalSteps[0].uniqObjectField));
 147           }
 148
 149           this._iframeService.addFullScreen();
 150
 151           const serviceInstance = this._store.getState().service.serviceInstance[serviceModelId];
 152           this._dialogService.addDialog(SearchElementsModalComponent, {
 153               modalInformation: this._networkStepService.getNetworkStep(serviceInstance, serviceModelId, ...modalSteps)
 154             }
 155           )
 156         },
 157         visible: (node) => this._sharedTreeService.shouldShowRemoveAndEdit(node),
 158         enable: (node) => this._sharedTreeService.shouldShowRemoveAndEdit(node),
 159       },
 160       delete: {
 161         method: (node, serviceModelId) => {
 162           this._store.dispatch(deleteActionVrfInstance(node.data.vrfStoreKey, serviceModelId));
 163         },
 164         visible: (node) => this._sharedTreeService.shouldShowDelete(node, serviceModelId),
 165         enable: (node) => this._sharedTreeService.shouldShowDelete(node, serviceModelId)
 166       },
 167       undoDelete: {
 168         method: (node, serviceModelId) => {
 169           this._store.dispatch(undoDeleteActionVrfInstance(node.data.vrfStoreKey, serviceModelId));
 170         },
 171         visible: (node) => this._sharedTreeService.shouldShowUndoDelete(node),
 172         enable: (node, serviceModelId) => this._sharedTreeService.shouldShowUndoDelete(node) && !this._sharedTreeService.isServiceOnDeleteMode(serviceModelId)
 173       }
 174     }
 175   }
 176
 177   updatePosition(that, node, instanceId): void {
 178     //TODO
 179   }
 180
 181   getNodePosition(instance): number {
 182     //TODO
 183     return 0;
 184   }
 185
 186   getInfo(model, instance): ModelInformationItem[] {
 187     const modelInformation = !_.isEmpty(model) ? [
 188       ModelInformationItem.createInstance("Min instances", "1"),
 189       ModelInformationItem.createInstance("Max instances", "1"),
 190       ModelInformationItem.createInstance("Association", "L3-Network - VPN")] : [];
 191     return modelInformation;
 192   }
 193 }
 194