catalog-ui/src/app/ng2/pages/composition/panel/panel-tabs/req-capabilities-tab/req-capabilities-tab.component.ts

   1 import { Component, OnInit, Input, OnDestroy } from '@angular/core';
   2 import { Component as TopologyTemplate, Capability, Requirement, CapabilitiesGroup, RequirementsGroup, ComponentInstance, FullComponentInstance } from "app/models";
   3 import { Store } from "@ngxs/store";
   4 import { GRAPH_EVENTS } from "app/utils";
   5 import { ComponentGenericResponse } from "app/ng2/services/responses/component-generic-response";
   6 import { TopologyTemplateService } from "app/ng2/services/component-services/topology-template.service";
   7 import { EventListenerService } from "app/services";
   8 import { WorkspaceService } from "app/ng2/pages/workspace/workspace.service";
   9 import { CompositionService } from "app/ng2/pages/composition/composition.service";
  10 import {SelectedComponentType, TogglePanelLoadingAction} from "../../../common/store/graph.actions";
  11
  12
  13 export class InstanceCapabilitiesMap {
  14     [key:string]:Array<Capability>;
  15 }
  16
  17 export class InstanceRequirementsMap {
  18     [key:string]:Array<Requirement>;
  19 }
  20
  21 @Component({
  22     selector: 'req-capabilities-tab',
  23     templateUrl: './req-capabilities-tab.component.html',
  24     styleUrls: ['./req-capabilities-tab.component.less']
  25 })
  26 export class ReqAndCapabilitiesTabComponent implements OnInit, OnDestroy {
  27
  28     isComponentInstanceSelected: boolean;
  29     capabilities:Array<Capability>;
  30     requirements:Array<Requirement>;
  31     capabilitiesInstancesMap:InstanceCapabilitiesMap;
  32     requirementsInstancesMap:InstanceRequirementsMap;
  33     objectKeys = Object.keys;
  34
  35     @Input() isViewOnly: boolean;
  36     @Input() componentType: SelectedComponentType;
  37     @Input() component: TopologyTemplate | FullComponentInstance;
  38     @Input() input: any;
  39
  40
  41     constructor(private store: Store,
  42         private topologyTemplateService:TopologyTemplateService,
  43         private workspaceService: WorkspaceService,
  44         private compositionService: CompositionService,
  45         private eventListenerService:EventListenerService) { }
  46
  47     ngOnInit(): void {
  48
  49         this.isComponentInstanceSelected = this.componentType === SelectedComponentType.COMPONENT_INSTANCE;
  50
  51         this.requirements = [];
  52         this.capabilities = [];
  53         this.initEvents();
  54         this.initRequirementsAndCapabilities();
  55
  56      }
  57
  58      private initEvents = ():void => {
  59         this.eventListenerService.registerObserverCallback(GRAPH_EVENTS.ON_NODE_SELECTED, this.initRequirementsAndCapabilities);
  60         this.eventListenerService.registerObserverCallback(GRAPH_EVENTS.ON_GRAPH_BACKGROUND_CLICKED, this.updateRequirementCapabilities);
  61         this.eventListenerService.registerObserverCallback(GRAPH_EVENTS.ON_CREATE_COMPONENT_INSTANCE,  this.updateRequirementCapabilities);
  62         this.eventListenerService.registerObserverCallback(GRAPH_EVENTS.ON_DELETE_COMPONENT_INSTANCE,  this.updateRequirementCapabilities);
  63     }
  64
  65      ngOnDestroy(): void {
  66         this.eventListenerService.unRegisterObserver(GRAPH_EVENTS.ON_NODE_SELECTED, this.initRequirementsAndCapabilities);
  67         this.eventListenerService.unRegisterObserver(GRAPH_EVENTS.ON_GRAPH_BACKGROUND_CLICKED, this.updateRequirementCapabilities);
  68         this.eventListenerService.unRegisterObserver(GRAPH_EVENTS.ON_CREATE_COMPONENT_INSTANCE, this.updateRequirementCapabilities);
  69         this.eventListenerService.unRegisterObserver(GRAPH_EVENTS.ON_DELETE_COMPONENT_INSTANCE, this.updateRequirementCapabilities);
  70      }
  71
  72      public isCurrentDisplayComponentIsComplex = ():boolean => {
  73
  74         if (this.component instanceof FullComponentInstance) {
  75             if (this.component.originType === 'VF') {
  76                 return true;
  77             }
  78             return false;
  79         } else {
  80             return this.component.isComplex();
  81         }
  82     }
  83
  84     private loadComplexComponentData = () => {
  85         this.store.dispatch(new TogglePanelLoadingAction({isLoading: true}));
  86
  87         this.topologyTemplateService.getCapabilitiesAndRequirements(this.workspaceService.metadata.componentType, this.workspaceService.metadata.uniqueId).subscribe((response:ComponentGenericResponse) => {
  88             this.workspaceService.metadata.capabilities = response.capabilities;
  89             this.workspaceService.metadata.requirements = response.requirements;
  90             this.setScopeCapabilitiesRequirements(response.capabilities, response.requirements);
  91             this.initInstancesMap();
  92             this.store.dispatch(new TogglePanelLoadingAction({isLoading: false}));
  93         }, (error) => { this.store.dispatch(new TogglePanelLoadingAction({isLoading: false})); });
  94     }
  95
  96
  97     private extractValuesFromMap = (map:CapabilitiesGroup | RequirementsGroup):Array<any> => {
  98         let values = [];
  99         _.forEach(map, (capabilitiesOrRequirements:Array<Capability> | Array<Requirement>, key) => {
 100                 values = values.concat(capabilitiesOrRequirements)
 101             }
 102         );
 103         return values;
 104     }
 105
 106     private setScopeCapabilitiesRequirements = (capabilities:CapabilitiesGroup, requirements:RequirementsGroup) => {
 107         this.capabilities = this.extractValuesFromMap(capabilities);
 108         this.requirements = this.extractValuesFromMap(requirements);
 109     }
 110
 111
 112     private initInstancesMap = ():void => {
 113
 114         this.capabilitiesInstancesMap = new InstanceCapabilitiesMap();
 115         _.forEach(this.capabilities, (capability:Capability) => {
 116             if (this.capabilitiesInstancesMap[capability.ownerName]) {
 117                 this.capabilitiesInstancesMap[capability.ownerName] = this.capabilitiesInstancesMap[capability.ownerName].concat(capability);
 118             } else {
 119                 this.capabilitiesInstancesMap[capability.ownerName] = new Array<Capability>(capability);
 120             }
 121         });
 122
 123         this.requirementsInstancesMap = new InstanceRequirementsMap();
 124         _.forEach(this.requirements, (requirement:Requirement) => {
 125             if (this.requirementsInstancesMap[requirement.ownerName]) {
 126                 this.requirementsInstancesMap[requirement.ownerName] = this.requirementsInstancesMap[requirement.ownerName].concat(requirement);
 127             } else {
 128                 this.requirementsInstancesMap[requirement.ownerName] = new Array<Requirement>(requirement);
 129             }
 130         });
 131     }
 132
 133     private initRequirementsAndCapabilities = (needUpdate?: boolean) => {
 134
 135         // if instance selected, we take the requirement and capabilities of the instance - always exist because we load them with the graph
 136         if (this.component instanceof FullComponentInstance) {
 137             this.store.dispatch(new TogglePanelLoadingAction({isLoading: false}));
 138             this.setScopeCapabilitiesRequirements(this.component.capabilities, this.component.requirements);
 139             if (this.component.originType === 'VF') {
 140                 this.initInstancesMap();
 141             }
 142         } else {
 143             // if instance not selected, we take the requirement and capabilities of the VF/SERVICE, if not exist we call api
 144             if (needUpdate || !this.component.capabilities || !this.component.requirements) {
 145                 this.loadComplexComponentData();
 146
 147             } else {
 148                 this.store.dispatch(new TogglePanelLoadingAction({isLoading: false}));
 149                 this.setScopeCapabilitiesRequirements(this.component.capabilities, this.component.requirements);
 150                 this.initInstancesMap();
 151             }
 152         }
 153     }
 154
 155     private updateRequirementCapabilities = () => {
 156         if (!this.isComponentInstanceSelected) {
 157             this.loadComplexComponentData();
 158         }
 159     }
 160
 161
 162
 163
 164 }
 165