catalog-ui/src/app/directives/graphs-v2/composition-graph/utils/composition-graph-zone-utils.ts

   1 import { PolicyInstance } from "app/models/graph/zones/policy-instance";
   2 import { ZoneInstance, ZoneInstanceType, ZoneInstanceAssignmentType } from "app/models/graph/zones/zone-instance";
   3 import { Zone } from "app/models/graph/zones/zone";
   4 import { DynamicComponentService } from "app/ng2/services/dynamic-component.service";
   5 import { PaletteAnimationComponent } from "app/ng2/components/ui/palette-animation/palette-animation.component";
   6 import { Point, LeftPaletteMetadataTypes, Component } from "../../../../models";
   7 import { CanvasHandleTypes } from "app/utils";
   8 import { PoliciesService } from "../../../../ng2/services/policies.service";
   9 import { Observable } from "rxjs";
  10 import { GroupsService } from "../../../../ng2/services/groups.service";
  11 import { GroupInstance } from "app/models/graph/zones/group-instance";
  12
  13
  14 export class CompositionGraphZoneUtils {
  15
  16     constructor(private dynamicComponentService: DynamicComponentService,
  17         private policiesService: PoliciesService,
  18         private groupsService: GroupsService) {
  19     }
  20
  21
  22     public createCompositionZones = (): Array<Zone> => {
  23         let zones: Array<Zone> = [];
  24
  25         zones[ZoneInstanceType.POLICY] = new Zone('Policies', 'P', ZoneInstanceType.POLICY);
  26         zones[ZoneInstanceType.GROUP] = new Zone('Groups', 'G', ZoneInstanceType.GROUP);
  27
  28         return zones;
  29     }
  30
  31     public showZone = (zone: Zone): void => {
  32         zone.visible = true;
  33         zone.minimized = false;
  34     }
  35
  36     public getZoneTypeForPaletteComponent = (componentCategory: LeftPaletteMetadataTypes) => {
  37         if (componentCategory == LeftPaletteMetadataTypes.Group) {
  38             return ZoneInstanceType.GROUP;
  39         } else if (componentCategory == LeftPaletteMetadataTypes.Policy) {
  40             return ZoneInstanceType.POLICY;
  41         }
  42     };
  43
  44     public initZoneInstances(zones: Array<Zone>, component: Component) {
  45         if (component.groupInstances && component.groupInstances.length) {
  46             this.showZone(zones[ZoneInstanceType.GROUP]);
  47             _.forEach(component.groupInstances, (group: GroupInstance) => {
  48                 let newInstance = new ZoneInstance(group, component);
  49                 this.addInstanceToZone(zones[ZoneInstanceType.GROUP], newInstance);
  50             });
  51         }
  52
  53         if (component.policies && component.policies.length) {
  54             this.showZone(zones[ZoneInstanceType.POLICY]);
  55             _.forEach(component.policies, (policy: PolicyInstance) => {
  56                 let newInstance = new ZoneInstance(policy, component);
  57                 this.addInstanceToZone(zones[ZoneInstanceType.POLICY], newInstance);
  58
  59             });
  60         }
  61     }
  62
  63     public findAndUpdateZoneInstanceData(zones: Array<Zone>, instanceData: PolicyInstance | GroupInstance) {
  64         _.forEach(zones, (zone: Zone) => {
  65             _.forEach(zone.instances, (zoneInstance: ZoneInstance) => {
  66                 if (zoneInstance.instanceData.uniqueId === instanceData.uniqueId) {
  67                     zoneInstance.updateInstanceData(instanceData);
  68                 }
  69             });
  70         });
  71     }
  72
  73     public updateTargetsOrMembersOnCanvasDelete = (canvasNodeID: string, zones: Array<Zone>, type: ZoneInstanceAssignmentType): void => {
  74         _.forEach(zones, (zone) => {
  75             _.forEach(zone.instances, (zoneInstance: ZoneInstance) => {
  76                 if (zoneInstance.isAlreadyAssigned(canvasNodeID)) {
  77                     zoneInstance.addOrRemoveAssignment(canvasNodeID, type);
  78                     //remove it from our list of BE targets and members as well (so that it will not be sent in future calls to BE).
  79                     zoneInstance.instanceData.setSavedAssignments(zoneInstance.assignments);
  80                 }
  81             });
  82         });
  83     };
  84
  85     public createZoneInstanceFromLeftPalette = (zoneType: ZoneInstanceType, component: Component, paletteComponentType: string): Observable<ZoneInstance> => {
  86         if (zoneType === ZoneInstanceType.POLICY) {
  87             return this.policiesService.createPolicyInstance(component.componentType, component.uniqueId, paletteComponentType).map(response => {
  88                 let newInstance = new PolicyInstance(response);
  89                 component.policies.push(newInstance);
  90                 return new ZoneInstance(newInstance, component);
  91             });
  92         } else if (zoneType === ZoneInstanceType.GROUP) {
  93             return this.groupsService.createGroupInstance(component.componentType, component.uniqueId, paletteComponentType).map(response => {
  94                 let newInstance = new GroupInstance(response);
  95                 component.groupInstances.push(newInstance);
  96                 return new ZoneInstance(newInstance, component);
  97             });
  98         }
  99     }
 100
 101     public addInstanceToZone(zone: Zone, instance: ZoneInstance, hide?: boolean) {
 102         if (hide) {
 103             instance.hidden = true;
 104         }
 105         zone.instances.push(instance);
 106
 107     };
 108
 109     private findZoneCoordinates(zoneType): Point {
 110         let point: Point = new Point(0, 0);
 111         let zone = angular.element(document.querySelector('.' + zoneType + '-zone'));
 112         let wrapperZone = zone.offsetParent();
 113         point.x = zone.prop('offsetLeft') + wrapperZone.prop('offsetLeft');
 114         point.y = zone.prop('offsetTop') + wrapperZone.prop('offsetTop');
 115         return point;
 116     }
 117
 118     public createPaletteToZoneAnimation = (startPoint: Point, zoneType: ZoneInstanceType, newInstance: ZoneInstance) => {
 119         let zoneTypeName = ZoneInstanceType[zoneType].toLowerCase();
 120         let paletteToZoneAnimation = this.dynamicComponentService.createDynamicComponent(PaletteAnimationComponent);
 121         paletteToZoneAnimation.instance.from = startPoint;
 122         paletteToZoneAnimation.instance.type = zoneType;
 123         paletteToZoneAnimation.instance.to = this.findZoneCoordinates(zoneTypeName);
 124         paletteToZoneAnimation.instance.zoneInstance = newInstance;
 125         paletteToZoneAnimation.instance.iconName = zoneTypeName;
 126         paletteToZoneAnimation.instance.runAnimation();
 127     }
 128
 129     public startCyTagMode = (cy: Cy.Instance) => {
 130         cy.autolock(true);
 131         cy.nodes().unselectify();
 132         cy.emit('tagstart'); //dont need to show handles because they're already visible bcz of hover event
 133
 134     };
 135
 136     public endCyTagMode = (cy: Cy.Instance) => {
 137         cy.emit('tagend');
 138         cy.nodes().selectify();
 139         cy.autolock(false);
 140     };
 141
 142     public handleTagClick = (cy: Cy.Instance, zoneInstance: ZoneInstance, nodeId: string) => {
 143         zoneInstance.addOrRemoveAssignment(nodeId, ZoneInstanceAssignmentType.COMPONENT_INSTANCES);
 144         this.showZoneTagIndicationForNode(nodeId, zoneInstance, cy);
 145     };
 146
 147     public showGroupZoneIndications = (groupInstances: Array<ZoneInstance>, policyInstance: ZoneInstance) => {
 148         groupInstances.forEach((groupInstance: ZoneInstance) => {
 149             let handle: string = this.getCorrectHandleForNode(groupInstance.instanceData.uniqueId, policyInstance);
 150             groupInstance.showHandle(handle);
 151         })
 152     };
 153
 154     public hideGroupZoneIndications = (instances: Array<ZoneInstance>) => {
 155         instances.forEach((instance) => {
 156             instance.hideHandle();
 157         })
 158     }
 159
 160     public showZoneTagIndications = (cy: Cy.Instance, zoneInstance: ZoneInstance) => {
 161
 162         cy.nodes().forEach(node => {
 163             let handleType: string = this.getCorrectHandleForNode(node.id(), zoneInstance);
 164             cy.emit('showhandle', [node, handleType]);
 165         });
 166     };
 167
 168     public showZoneTagIndicationForNode = (nodeId: string, zoneInstance: ZoneInstance, cy: Cy.Instance) => {
 169         let node = cy.getElementById(nodeId);
 170         let handleType: string = this.getCorrectHandleForNode(nodeId, zoneInstance);
 171         cy.emit('showhandle', [node, handleType]);
 172     }
 173
 174     public hideZoneTagIndications = (cy: Cy.Instance) => {
 175         cy.emit('hidehandles');
 176     };
 177
 178     public getCorrectHandleForNode = (nodeId: string, zoneInstance: ZoneInstance): string => {
 179         if (zoneInstance.isAlreadyAssigned(nodeId)) {
 180             if (zoneInstance.type == ZoneInstanceType.POLICY) {
 181                 return CanvasHandleTypes.TAGGED_POLICY;
 182             } else {
 183                 return CanvasHandleTypes.TAGGED_GROUP;
 184             }
 185         } else {
 186             return CanvasHandleTypes.TAG_AVAILABLE;
 187         }
 188     };
 189 }
 190
 191 CompositionGraphZoneUtils.$inject = [
 192     'DynamicComponentService',
 193     'PoliciesServiceNg2',
 194     'GroupsServiceNg2'
 195 ];