vid-webpack-master/src/app/drawingBoard/service-planning/available-models-tree/available-models-tree.component.ts

   1 import {Component, EventEmitter, Output, ViewChild} from '@angular/core';
   2 import {ITreeOptions, TreeComponent} from 'angular-tree-component';
   3 import {IDType, ITreeNode} from 'angular-tree-component/dist/defs/api';
   4 import {DialogService} from 'ng2-bootstrap-modal';
   5 import {AvailableModelsTreeService} from './available-models-tree.service';
   6 import {NgRedux} from "@angular-redux/store";
   7 import {ActivatedRoute} from '@angular/router';
   8 import {AppState} from '../../../shared/store/reducers';
   9 import {AaiService} from '../../../shared/services/aaiService/aai.service';
  10 import {ServiceNodeTypes} from '../../../shared/models/ServiceNodeTypes';
  11 import {IframeService} from "../../../shared/utils/iframe.service";
  12 import {DefaultDataGeneratorService} from "../../../shared/services/defaultDataServiceGenerator/default.data.generator.service";
  13 import {VfModulePopupService} from "../../../shared/components/genericFormPopup/genericFormServices/vfModule/vfModule.popup.service";
  14 import {NetworkPopupService} from "../../../shared/components/genericFormPopup/genericFormServices/network/network.popup.service";
  15 import {createVFModuleInstance} from "../../../shared/storeUtil/utils/vfModule/vfModule.actions";
  16 import {VnfPopupService} from "../../../shared/components/genericFormPopup/genericFormServices/vnf/vnf.popup.service";
  17 import {DrawingBoardModes} from "../drawing-board.modes";
  18 import {DrawingBoardTreeService} from "../drawing-board-tree/drawing-board-tree.service";
  19 import {ObjectToModelTreeService} from "../objectsToTree/objectToModelTree/objectToModelTree.service";
  20 import {VnfGroupPopupService} from "../../../shared/components/genericFormPopup/genericFormServices/vnfGroup/vnfGroup.popup.service";
  21 import {SharedTreeService} from "../objectsToTree/shared.tree.service";
  22 import {changeInstanceCounter} from "../../../shared/storeUtil/utils/general/general.actions";
  23 import {createVnfGroupInstance} from "../../../shared/storeUtil/utils/vnfGroup/vnfGroup.actions";
  24 import {VnfGroupControlGenerator} from "../../../shared/components/genericForm/formControlsServices/vnfGroupGenerator/vnfGroup.control.generator";
  25 import {HighlightPipe} from "../../../shared/pipes/highlight/highlight-filter.pipe";
  26 import * as _ from 'lodash';
  27 import {DrawingBoardTreeComponent} from "../drawing-board-tree/drawing-board-tree.component";
  28 import {ComponentInfoModel} from "../component-info/component-info-model";
  29 import {ComponentInfoService} from "../component-info/component-info.service";
  30 import {FeatureFlagsService, Features} from "../../../shared/services/featureFlag/feature-flags.service";
  31 import {Utils} from "../../../shared/utils/utils";
  32
  33
  34 @Component({
  35   selector: 'available-models-tree',
  36   templateUrl: './available-models-tree.component.html',
  37   styleUrls: ['./available-models-tree.component.scss'],
  38   providers : [HighlightPipe]
  39 })
  40
  41 export class AvailableModelsTreeComponent {
  42   filterValue : string = '';
  43   serviceModelId: string;
  44   serviceHierarchy;
  45   parentElementClassName = 'content';
  46   _store: NgRedux<AppState>;
  47   isNewObject: boolean;
  48   availableModelsTreeService: AvailableModelsTreeService;
  49   drawingBoardTreeService: DrawingBoardTreeService;
  50
  51   constructor(private _iframeService: IframeService,
  52               private _aaiService: AaiService,
  53               private route: ActivatedRoute,
  54               private dialogService: DialogService,
  55               private _availableModelsTreeService: AvailableModelsTreeService,
  56               private _drawingBoardTreeService: DrawingBoardTreeService,
  57               private _defaultDataGeneratorService: DefaultDataGeneratorService,
  58               private _vnfGroupControlGenerator: VnfGroupControlGenerator,
  59               private _vfModulePopuopService: VfModulePopupService,
  60               private _vnfGroupPopupService: VnfGroupPopupService,
  61               private _vnfPopupService: VnfPopupService,
  62               private _networkPopupService: NetworkPopupService,
  63               private  store: NgRedux<AppState>,
  64               private _objectToModelTreeService : ObjectToModelTreeService,
  65               private  _sharedTreeService : SharedTreeService,
  66               private _highlightPipe : HighlightPipe) {
  67     this.availableModelsTreeService = _availableModelsTreeService;
  68     this.drawingBoardTreeService = _drawingBoardTreeService;
  69
  70     this._store = store;
  71     this.route
  72       .queryParams
  73       .subscribe(params => {
  74         this.serviceModelId = params['serviceModelId'];
  75         this._aaiService.getServiceModelById(this.serviceModelId).subscribe(
  76           value => {
  77             this.serviceHierarchy = value;
  78             this.nodes = this._objectToModelTreeService.convertServiceHierarchyModelToTreeNodes(this.serviceHierarchy);
  79             this.shouldOpenVRFModal(this.nodes);
  80           },
  81           error => {
  82             console.log('error is ', error)
  83           }
  84         );
  85       });
  86
  87   }
  88
  89   @Output()
  90   highlightInstances: EventEmitter<number> = new EventEmitter<number>();
  91   @ViewChild('tree', {static: false}) tree: TreeComponent;
  92
  93   nodes = [];
  94   service = {name: ''};
  95
  96   options: ITreeOptions = {
  97     allowDrop:false,
  98     nodeHeight: 36,
  99     dropSlotHeight: 0,
 100     nodeClass: (node: ITreeNode) => {
 101       if (node.data.type === ServiceNodeTypes.VFmodule && ! node.parent.data['getNodeCount'](node.parent, this.serviceModelId) && this.store.getState().global.drawingBoardStatus !== DrawingBoardModes.VIEW) {
 102         node.data.disabled = true;
 103         return 'tree-node tree-node-disabled';
 104       }
 105       node.data.disabled = false;
 106       return 'tree-node';
 107     }
 108   };
 109
 110
 111   shouldOpenVRFModal(nodes) :void {
 112     const node = this._availableModelsTreeService.shouldOpenVRFModal(nodes, this.serviceModelId, this.store.getState().service);
 113     if(!_.isNil(node)){
 114       this.onClickAdd(node,  this.serviceModelId);
 115     }
 116   }
 117
 118   getNodeName(node : ITreeNode, filter : string) {
 119     return this._highlightPipe.transform(node.data.name ,filter ? filter : '');
 120   }
 121
 122   expandParentByNodeId(id: IDType): void {
 123     this.tree.treeModel.getNodeById(id).parent.expand();
 124   }
 125
 126   updateNodes(updateData : {nodes : any, filterValue : string}) : void {
 127     this.nodes = updateData.nodes;
 128     this.filterValue = updateData.filterValue;
 129   }
 130
 131   selectNode(node: ITreeNode): void {
 132     node.expand();
 133     this._sharedTreeService.setSelectedVNF(null);
 134     this.highlightInstances.emit(node.data.modelUniqueId);
 135     if (FeatureFlagsService.getFlagState(Features.FLAG_1906_COMPONENT_INFO, this.store)) {
 136       const serviceHierarchy = this._store.getState().service.serviceHierarchy[this.serviceModelId];
 137
 138       const instanceModel = this._sharedTreeService.modelByIdentifiers(
 139         serviceHierarchy, node.data.modelTypeName,
 140         this._sharedTreeService.modelUniqueNameOrId(node.data), node.data.name
 141       );
 142
 143       const model = node.data.getModel(instanceModel);
 144       const modelInfoItems  = node.data.getInfo(model, null);
 145       const componentInfoModel :ComponentInfoModel = this._sharedTreeService.addGeneralInfoItems(modelInfoItems, node.data.componentInfoType, model, null);
 146       ComponentInfoService.triggerComponentInfoChange.next(componentInfoModel);
 147     }
 148   }
 149
 150
 151
 152   onClickAdd(node: ITreeNode, serviceId: string ,  isNewObject: boolean = false): void {
 153     this.isNewObject = isNewObject;
 154     let data = node.data;
 155     let dynamicInputs = data.dynamicInputs;
 156     let isAlaCarte: boolean = Utils.isALaCarte(this.serviceHierarchy.service.vidNotions.instantiationType);
 157     let isEcompGeneratedNaming: boolean = data.isEcompGeneratedNaming;
 158     let type: string = data.type;
 159     if (node.data.type === ServiceNodeTypes.VF ||
 160       this._availableModelsTreeService.shouldOpenDialog(type, dynamicInputs, isEcompGeneratedNaming)) {
 161       this._iframeService.addClassOpenModal(this.parentElementClassName);
 162       node.data.onAddClick(node, serviceId);
 163     } else {
 164       if (node.data.type === ServiceNodeTypes.VnfGroup)  {
 165         let instanceName = this._vnfGroupControlGenerator.getDefaultInstanceName(null, serviceId, node.data.name);
 166         let vnfGroup = this._defaultDataGeneratorService.generateVnfGroupInstance(this.serviceHierarchy.vnfGroups[node.data.name], isEcompGeneratedNaming, isAlaCarte, instanceName);
 167         this._store.dispatch(changeInstanceCounter(node.data.modelUniqueId, serviceId, 1 , <any> {data: {type: 'VnfGroup'}}));
 168         this._store.dispatch(createVnfGroupInstance(vnfGroup, node.data.name, serviceId, node.data.name));
 169         DrawingBoardTreeComponent.triggerreCalculateIsDirty.next(this.serviceModelId);
 170       } else {
 171         let vfModule = this._defaultDataGeneratorService.generateVFModule(this.serviceHierarchy.vnfs[node.parent.data.name].vfModules[node.data.name], dynamicInputs, isEcompGeneratedNaming, isAlaCarte);
 172         if (this._sharedTreeService.selectedVNF) {
 173           this.store.dispatch(createVFModuleInstance(vfModule, node.data.name, this.serviceModelId, null, this._sharedTreeService.selectedVNF));
 174           DrawingBoardTreeComponent.triggerreCalculateIsDirty.next(this.serviceModelId);
 175         } else if (this._availableModelsTreeService.getOptionalVNFs(this.serviceModelId, node.parent.data.modelUniqueId).length === 1) {
 176           let existVnf = this._store.getState().service.serviceInstance[this.serviceModelId].vnfs;
 177           if(!_.isNil(existVnf)){
 178             for(let vnfKey in existVnf){
 179               const modelUniqueId = this._sharedTreeService.modelUniqueId(existVnf[vnfKey]);
 180               if(modelUniqueId === node.parent.data.id){
 181                 this.store.dispatch(createVFModuleInstance(vfModule, node.data.name, this.serviceModelId, null, vnfKey));
 182                 DrawingBoardTreeComponent.triggerreCalculateIsDirty.next(this.serviceModelId);
 183               }
 184             }
 185           }
 186
 187
 188         } else {
 189           this._availableModelsTreeService.addingAlertAddingNewVfModuleModal();
 190         }
 191       }
 192     }
 193   }
 194 }