vid-webpack-master/src/app/drawingBoard/service-planning/drawing-board-tree/drawing-board-tree.component.ts

   1 import {AfterViewInit, Component, EventEmitter, Input, OnInit, Output, ViewChild,} from '@angular/core';
   2 import {ContextMenuComponent, ContextMenuService} from 'ngx-contextmenu';
   3 import {Constants} from '../../../shared/utils/constants';
   4 import {IDType, ITreeNode} from "angular-tree-component/dist/defs/api";
   5 import {TreeComponent, TreeModel, TreeNode} from "angular-tree-component";
   6 import {DialogService} from "ng2-bootstrap-modal";
   7 import {ActivatedRoute} from "@angular/router";
   8 import {NgRedux} from "@angular-redux/store";
   9 import {AppState} from "../../../shared/store/reducers";
  10 import {IframeService} from "../../../shared/utils/iframe.service";
  11 import {DuplicateService} from '../duplicate/duplicate.service';
  12 import {DrawingBoardTreeService, TreeNodeContextMenuModel} from "./drawing-board-tree.service";
  13 import {NetworkPopupService} from "../../../shared/components/genericFormPopup/genericFormServices/network/network.popup.service";
  14 import {VfModulePopuopService} from "../../../shared/components/genericFormPopup/genericFormServices/vfModule/vfModule.popuop.service";
  15 import {VnfPopupService} from "../../../shared/components/genericFormPopup/genericFormServices/vnf/vnf.popup.service";
  16 import {SdcUiServices} from "onap-ui-angular";
  17 import {HighlightPipe} from "../../../shared/pipes/highlight/highlight-filter.pipe";
  18 import {VnfGroupPopupService} from "../../../shared/components/genericFormPopup/genericFormServices/vnfGroup/vnfGroup.popup.service";
  19 import {ObjectToInstanceTreeService} from "../objectsToTree/objectToInstanceTree/objectToInstanceTree.service";
  20 import {SharedTreeService} from "../objectsToTree/shared.tree.service";
  21 import {Subject} from "rxjs/Subject";
  22 import {changeServiceIsDirty} from "../../../shared/storeUtil/utils/service/service.actions";
  23 import * as _ from 'lodash';
  24 import {ErrorMsgService} from "../../../shared/components/error-msg/error-msg.service";
  25 import {DragAndDropService} from "./dragAndDrop/dragAndDrop.service";
  26 import {FeatureFlagsService, Features} from "../../../shared/services/featureFlag/feature-flags.service";
  27 import {ComponentInfoService} from "../component-info/component-info.service";
  28 import {ComponentInfoModel} from "../component-info/component-info-model";
  29 import {ObjectToModelTreeService} from "../objectsToTree/objectToModelTree/objectToModelTree.service";
  30 import {DrawingBoardModes} from "../drawing-board.modes";
  31
  32 @Component({
  33   selector: 'drawing-board-tree',
  34   templateUrl: './drawing-board-tree.html',
  35   styleUrls: ['./drawing-board-tree.scss'],
  36   providers: [HighlightPipe]
  37 })
  38
  39 export class DrawingBoardTreeComponent implements OnInit, AfterViewInit {
  40   _store: NgRedux<AppState>;
  41   duplicateService: DuplicateService;
  42   drawingBoardTreeService: DrawingBoardTreeService;
  43   objectToModelTreeService : ObjectToModelTreeService;
  44   objectToInstanceTreeService : ObjectToInstanceTreeService;
  45   errorMsgService: ErrorMsgService;
  46   isFilterEnabled: boolean = false;
  47   filterValue: string = '';
  48   contextMenuOptions: TreeNodeContextMenuModel[];
  49
  50   @Input() pageMode : DrawingBoardModes;
  51   static triggerDeleteActionService: Subject<string> = new Subject<string>();
  52   static triggerUndoDeleteActionService: Subject<string> = new Subject<string>();
  53   static triggerreCalculateIsDirty: Subject<string> = new Subject<string>();
  54   @ViewChild(ContextMenuComponent) public contextMenu: ContextMenuComponent;
  55
  56   constructor(private _contextMenuService: ContextMenuService,
  57               private _iframeService: IframeService,
  58               private dialogService: DialogService,
  59               private store: NgRedux<AppState>,
  60               private route: ActivatedRoute,
  61               private _duplicateService: DuplicateService,
  62               private modalService: SdcUiServices.ModalService,
  63               private _drawingBoardTreeService: DrawingBoardTreeService,
  64               private _networkPopupService: NetworkPopupService,
  65               private _vfModulePopuopService: VfModulePopuopService,
  66               private _vnfPopupService: VnfPopupService,
  67               private _vnfGroupPopupService: VnfGroupPopupService,
  68               private _errorMsgService: ErrorMsgService,
  69               private _highlightPipe: HighlightPipe,
  70               private _objectToInstanceTreeService: ObjectToInstanceTreeService,
  71               private _sharedTreeService: SharedTreeService,
  72               private _dragAndDropService : DragAndDropService,
  73               private _objectToModelTreeService : ObjectToModelTreeService,
  74               private _componentInfoService: ComponentInfoService) {
  75
  76     this.errorMsgService = _errorMsgService;
  77     this.duplicateService = _duplicateService;
  78     this.drawingBoardTreeService = _drawingBoardTreeService;
  79     this.contextMenuOptions = _drawingBoardTreeService.generateContextMenuOptions();
  80     this.objectToModelTreeService = _objectToModelTreeService;
  81     this.objectToInstanceTreeService = _objectToInstanceTreeService;
  82     DrawingBoardTreeComponent.triggerDeleteActionService.subscribe((serviceModelId) => {
  83       this._sharedTreeService.shouldShowDeleteInstanceWithChildrenModal(this.nodes, serviceModelId, (node, serviceModelId)=>{
  84         this.drawingBoardTreeService.deleteActionService(this.nodes, serviceModelId);
  85         this.store.dispatch(changeServiceIsDirty(this.nodes, serviceModelId));
  86       });
  87     });
  88
  89     DrawingBoardTreeComponent.triggerUndoDeleteActionService.subscribe((serviceModelId) => {
  90       this.drawingBoardTreeService.undoDeleteActionService(this.nodes, serviceModelId);
  91       this.store.dispatch(changeServiceIsDirty(this.nodes, serviceModelId));
  92     });
  93
  94     DrawingBoardTreeComponent.triggerreCalculateIsDirty.subscribe((serviceModelId) => {
  95       this.store.dispatch(changeServiceIsDirty(this.nodes, serviceModelId));
  96     });
  97
  98     this._store = store;
  99     this.route
 100       .queryParams
 101       .subscribe(params => {
 102         this.serviceModelId = params['serviceModelId'];
 103       });
 104   }
 105
 106   getNodeId(node: ITreeNode): string {
 107     return (node.data.parentType !== "" ? (node.data.parentType + "_") : "") + node.data.typeName;
 108   }
 109
 110   updateNodes(updateData: { nodes: any, filterValue: string }): void {
 111     this.nodes = updateData.nodes;
 112     this.filterValue = updateData.filterValue;
 113   }
 114
 115   isLinkedInstance = (node) : boolean => {
 116     return !_.isNil(node) && node.parentType === "VRF" || node.parentType === "VnfGroup";
 117   };
 118
 119   @Output()
 120   highlightNode: EventEmitter<number> = new EventEmitter<number>();
 121
 122   @ViewChild('tree') tree: TreeComponent;
 123   missingDataTooltip: string = Constants.Error.MISSING_VNF_DETAILS;
 124   currentNode: ITreeNode = null;
 125   flags: any;
 126   nodes = [];
 127   serviceModelId: string;
 128   options = {
 129     allowDrag: this._dragAndDropService.isAllow(),
 130     actionMapping: {
 131       mouse: {
 132         drop: (tree:TreeModel, node:TreeNode, $event:any, {from, to}) => {
 133           this._dragAndDropService.drag(this.store, this.serviceModelId, this.nodes, {from, to});
 134         }
 135       }
 136     },
 137     nodeHeight: 45,
 138     dropSlotHeight: 1
 139   };
 140   parentElementClassName = 'content';
 141
 142   ngOnInit(): void {
 143     this.store.subscribe(() => {
 144       this.updateTree();
 145     });
 146     this.updateTree()
 147   }
 148
 149   getNodeName(node: ITreeNode, filter: string) {
 150       return this._highlightPipe.transform(node.data.name, filter ? filter : '');
 151   }
 152
 153   updateTree() {
 154     const serviceInstance = this.store.getState().service.serviceInstance[this.serviceModelId];
 155     this.nodes = this._objectToInstanceTreeService.convertServiceInstanceToTreeData(serviceInstance, this.store.getState().service.serviceHierarchy[this.serviceModelId]).filter((item) => item !== null);
 156     console.log('right nodes', this.nodes);
 157
 158   }
 159
 160
 161   ngAfterViewInit(): void {
 162     this.tree.treeModel.expandAll();
 163   }
 164
 165   public onContextMenu($event: MouseEvent, node: ITreeNode): void {
 166     this.flags = this.store.getState().global.flags;
 167
 168     this.currentNode = node;
 169     node.focus();
 170     node.setActiveAndVisible(false);
 171     this.selectNode(node);
 172     setTimeout(() => {
 173       this._contextMenuService.show.next({
 174         contextMenu: this.contextMenu,
 175         event: <any>$event,
 176         item: node,
 177       });
 178       $event.preventDefault();
 179       $event.stopPropagation();
 180     }, 250);
 181
 182   }
 183
 184
 185   executeMenuAction(methodName: string): void {
 186     if (!_.isNil(this.currentNode.data.menuActions) && !_.isNil(this.currentNode.data.menuActions[methodName])) {
 187       this.currentNode.data.menuActions[methodName]['method'](this.currentNode, this.serviceModelId);
 188       this.store.dispatch(changeServiceIsDirty(this.nodes, this.serviceModelId));
 189     }
 190   }
 191
 192   isEnabled(node: ITreeNode, serviceModelId: string, methodName: string): boolean {
 193     if (!_.isNil(this.currentNode) && !_.isNil(this.currentNode.data.menuActions) && !_.isNil(this.currentNode.data.menuActions[methodName])) {
 194       return this.currentNode.data.menuActions[methodName]['enable'](this.currentNode, this.serviceModelId);
 195     }
 196     return false;
 197   }
 198
 199   isVisible(node: ITreeNode, methodName: string): boolean {
 200     if (!_.isNil(this.currentNode) && !_.isNil(this.currentNode.data.menuActions) && !_.isNil(this.currentNode.data.menuActions[methodName])) {
 201       return this.currentNode.data.menuActions[methodName]['visible'](this.currentNode, this.serviceModelId);
 202     }
 203     return false;
 204   }
 205
 206   public selectNode(node: ITreeNode): void {
 207     node.expand();
 208     this._sharedTreeService.setSelectedVNF(node);
 209     this.highlightNode.emit(node.data.modelUniqueId);
 210     if (FeatureFlagsService.getFlagState(Features.FLAG_1906_COMPONENT_INFO, this.store)) {
 211       const serviceHierarchy = this._store.getState().service.serviceHierarchy[this.serviceModelId];
 212       const model = node.data.getModel(node.data.modelName, node.data, serviceHierarchy);
 213       const modelInfoItems = node.data.getInfo(model, node.data);
 214       const componentInfoModel: ComponentInfoModel = this._sharedTreeService.addGeneralInfoItems(modelInfoItems, node.data.componentInfoType, model, node.data);
 215       ComponentInfoService.triggerComponentInfoChange.next(componentInfoModel);
 216     }
 217   }
 218
 219   expandParentByNodeId(id: IDType): void {
 220     this.tree.treeModel.getNodeById(id).parent.expand();
 221   }
 222
 223 }
 224
 225