@openziti/ziti-console-lib 0.3.1 → 0.4.0

package/esm2022/lib/features/visualizer/network-visualizer/network-visualizer.component.mjs

@@ -0,0 +1,1508 @@
+/* eslint prefer-const: 1 */
+import { Component, Inject, ViewEncapsulation, } from '@angular/core';
+import { SETTINGS_SERVICE, } from '../../../services/settings.service';
+import { ZITI_DATA_SERVICE, } from '../../../services/ziti-data.service';
+import { VisualizerServiceClass } from '../visualizer-service.class';
+import * as d3 from 'd3';
+import _ from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../messaging/logger.service";
+import * as i3 from "./network-visualizer.treenodeprocessor";
+import * as i4 from "./network-visualizer.helper";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/forms";
+import * as i7 from "@angular/material/autocomplete";
+import * as i8 from "@angular/material/core";
+import * as i9 from "../../loading-indicator/loading-indicator.component";
+import * as i10 from "../../../services/settings.service";
+import * as i11 from "../../../services/ziti-data.service";
+class NetworkVisualizerComponent extends VisualizerServiceClass {
+    constructor(settingsService, zitiService, httpClient, logger, treeNodeProcessor, topologyHelper) {
+        super();
+        this.settingsService = settingsService;
+        this.zitiService = zitiService;
+        this.httpClient = httpClient;
+        this.logger = logger;
+        this.treeNodeProcessor = treeNodeProcessor;
+        this.topologyHelper = topologyHelper;
+        // export class NetworkVisualizerComponent  implements OnInit {
+        this.title = 'Network Visualizer';
+        this.uniqId = 0;
+        this.fullScreen = false;
+        this.isLoading = true;
+        this.noSearchResults = false;
+        this.servicePoliciesTreeNodes = [];
+        this.servicesTreeNodes = [];
+        this.identitiesTreeNodes = [];
+        this.edgeroutersTreeNodes = [];
+        this.erPoliciesTreeNodes = [];
+        this.serviceEdgeRouterPolicyTreeNodes = [];
+        this.resourceTypeError = false;
+        this.filterText = '';
+        this.resourceType = '';
+        this.openNodes = [];
+        this.contextmenuNodeType = [];
+        // super(settingsService, zitiService);
+    }
+    ngOnInit() {
+        this.getNetworkObjects();
+    }
+    getPagingObject(pagesize) {
+        const paging = {
+            searchOn: 'name',
+            noSearch: false,
+            filter: '',
+            total: pagesize,
+            page: 1,
+            sort: 'name',
+            order: 'asc',
+        };
+        return paging;
+    }
+    async getNetworkObjects() {
+        this.isLoading = true;
+        await this.readAllObjects();
+        this.processFirstNetworkGraph();
+    }
+    async fetchIdentities(pagesize) {
+        const identities_paging = this.getPagingObject(pagesize);
+        return await this.zitiService
+            .get(`identities`, identities_paging, [])
+            .then(async (result) => {
+            this.identities = result.data;
+            if (!this.identities || this.identities.length === 0) {
+                this.identities = [];
+                this.isLoading = false;
+            }
+            else {
+                const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);
+                const promises = [];
+                for (let page = 2; page <= pages; page++) {
+                    identities_paging.page = page;
+                    const tmp_promise = await this.zitiService
+                        .get(`identities`, identities_paging, []).then((pageResult) => {
+                        pageResult.data.forEach((serv) => {
+                            this.identities.push(serv);
+                        });
+                    });
+                    promises.push(tmp_promise);
+                }
+                Promise.all(promises).then(() => { });
+            }
+        }).catch(error => {
+            this.logger.error('Error in fetching Identities', error.message);
+        }); // identity promises
+    }
+    async fetchServices(pagesize) {
+        const services_paging = this.getPagingObject(pagesize);
+        return await this.zitiService
+            .get(`services`, services_paging, [])
+            .then(async (result) => {
+            this.services = result.data;
+            if (!this.services || this.services.length === 0) {
+                this.services = [];
+                this.isLoading = false;
+            }
+            else {
+                const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);
+                const s_promises = [];
+                for (let page = 2; page <= pages; page++) {
+                    services_paging.page = page;
+                    const tmp_promise = await this.zitiService
+                        .get(`services`, services_paging, [])
+                        .then((pageResult) => {
+                        pageResult.data.forEach((serv) => {
+                            this.services.push(serv);
+                        });
+                    });
+                    s_promises.push(tmp_promise);
+                }
+                Promise.all(s_promises).then(() => { });
+            }
+        }).catch(error => {
+            this.logger.error('Error in fetching services', error.message);
+        });
+    }
+    async fetchServicePolicies(pagesize) {
+        const servicesPolicies_paging = this.getPagingObject(pagesize);
+        return await this.zitiService
+            .get(`service-policies`, servicesPolicies_paging, [])
+            .then(async (result) => {
+            this.service_policies = result.data;
+            if (!this.service_policies || this.service_policies.length === 0) {
+                this.service_policies = [];
+                this.isLoading = false;
+            }
+            else {
+                const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);
+                const sp_promises = [];
+                for (let page = 2; page <= pages; page++) {
+                    servicesPolicies_paging.page = page;
+                    const tmp_promise = await this.zitiService
+                        .get(`service-policies`, servicesPolicies_paging, [])
+                        .then((pageResult) => {
+                        pageResult.data.forEach((serv) => {
+                            this.service_policies.push(serv);
+                        });
+                    });
+                    sp_promises.push(tmp_promise);
+                }
+                Promise.all(sp_promises).then(() => { });
+            }
+        }).catch(error => {
+            this.logger.error('Error in fetching service-policies', error.message);
+        });
+    }
+    async fetchEdgeRouters(pagesize) {
+        const routers_paging = this.getPagingObject(pagesize);
+        return await this.zitiService
+            .get(`edge-routers`, routers_paging, [])
+            .then(async (result) => {
+            this.edgerouters = result.data;
+            if (!this.edgerouters || this.edgerouters.length === 0) {
+                this.edgerouters = [];
+                this.isLoading = false;
+            }
+            else {
+                const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);
+                const r_promises = [];
+                for (let page = 2; page <= pages; page++) {
+                    routers_paging.page = page;
+                    const tmp_promise = await this.zitiService
+                        .get(`edge-routers`, routers_paging, [])
+                        .then((pageResult) => {
+                        pageResult.data.forEach((serv) => {
+                            this.edgerouters.push(serv);
+                        });
+                    });
+                    r_promises.push(tmp_promise);
+                }
+                Promise.all(r_promises).then(() => { });
+            }
+        }).catch(error => {
+            this.logger.error('Error in fetching edge-routers', error.message);
+        });
+    }
+    async findEdgeRouterPolicies(pagesize) {
+        this.router_policies = [];
+        const erpolicies_paging = this.getPagingObject(pagesize);
+        return await this.zitiService
+            .get(`edge-router-policies`, erpolicies_paging, [])
+            .then(async (result) => {
+            this.router_policies = result.data;
+            if (!this.router_policies || this.router_policies.length === 0) {
+                this.isLoading = false;
+            }
+            else {
+                const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);
+                const r_promises = [];
+                for (let page = 2; page <= pages; page++) {
+                    erpolicies_paging.page = page;
+                    const tmp_promise = await this.zitiService
+                        .get(`edge-router-policies`, erpolicies_paging, [])
+                        .then((pageResult) => {
+                        pageResult.data.forEach((serv) => {
+                            this.router_policies.push(serv);
+                        });
+                    });
+                    r_promises.push(tmp_promise);
+                }
+                Promise.all(r_promises).then(() => { });
+            }
+        }).catch(error => {
+            this.logger.error('Error in fetching edge-router-policies', error);
+        });
+    }
+    async fetchServiceEdgeRouterPolicies(pagesize) {
+        this.service_router_policies = [];
+        const serp_paging = this.getPagingObject(pagesize);
+        return await this.zitiService
+            .get(`service-edge-router-policies`, serp_paging, [])
+            .then(async (result) => {
+            this.service_router_policies = result.data;
+            if (!this.service_router_policies || this.service_router_policies.length === 0) {
+                this.isLoading = false;
+            }
+            else {
+                const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);
+                const r_promises = [];
+                for (let page = 2; page <= pages; page++) {
+                    serp_paging.page = page;
+                    const tmp_promise = await this.zitiService
+                        .get(`service-edge-router-policies`, serp_paging, [])
+                        .then((pageResult) => {
+                        pageResult.data.forEach((serv) => {
+                            this.service_router_policies.push(serv);
+                        });
+                    });
+                    r_promises.push(tmp_promise);
+                }
+                Promise.all(r_promises).then(() => { });
+            }
+        }).catch(error => {
+            this.logger.error('Error in fetching service-edge-router-policies', error);
+        });
+    }
+    async fetchConfigs(pagesize) {
+        this.configs = [];
+        const configs_paging = this.getPagingObject(pagesize);
+        return await this.zitiService
+            .get(`configs`, configs_paging, [])
+            .then(async (result) => {
+            this.configs = result.data;
+            if (!this.configs || this.configs.length === 0) {
+                this.configs = [];
+            }
+            else {
+                const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);
+                const r_promises = [];
+                for (let page = 2; page <= pages; page++) {
+                    configs_paging.page = page;
+                    const tmp_promise = await this.zitiService
+                        .get(`configs`, configs_paging, [])
+                        .then((pageResult) => {
+                        pageResult.data.forEach((serv) => {
+                            this.configs.push(serv);
+                        });
+                    });
+                    r_promises.push(tmp_promise);
+                }
+                Promise.all(r_promises).then(() => { });
+            }
+        }).catch(error => {
+            this.logger.error('Error in fetching configs', error);
+        });
+    }
+    async readAllObjects() {
+        const myPromise = await new Promise((resolve, reject) => {
+            let networkVisPromises = [];
+            const pagesize = 500;
+            const eps = this.fetchIdentities(pagesize);
+            const ss = this.fetchServices(pagesize);
+            const sps = this.fetchServicePolicies(pagesize);
+            const ers = this.fetchEdgeRouters(pagesize);
+            const erps = this.findEdgeRouterPolicies(pagesize);
+            const serps = this.fetchServiceEdgeRouterPolicies(pagesize);
+            const cfg = this.fetchConfigs(pagesize);
+            Promise.all([eps, ss, sps, ers, erps, erps, serps, cfg]).then(() => {
+                resolve('end');
+            });
+        });
+    }
+    processFirstNetworkGraph() {
+        try {
+            const treeObj = this.topologyHelper.getResourceTreeObj('this.currentNetwork.name', 'this.currentNetwork.status', this.services, this.identities, this.service_policies, this.edgerouters, this.router_policies, this.service_router_policies, this.uniqId, this.logger);
+            this.uniqId = treeObj.lastId;
+            this.networkGraph = d3.hierarchy(treeObj, function (d) {
+                return d.children;
+            });
+            this.baseNetworkGraph = this.networkGraph;
+            this.servicePoliciesTreeNodes = [];
+            this.servicesTreeNodes = [];
+            this.identitiesTreeNodes = [];
+            this.edgeroutersTreeNodes = [];
+            this.erPoliciesTreeNodes = [];
+            this.serviceEdgeRouterPolicyTreeNodes = [];
+            this.servicePoliciesTreeNodes = this.fillAutoCompleteTreeNodes(this.networkGraph.children[0], this.servicePoliciesTreeNodes, 'ServicePolicy');
+            this.servicesTreeNodes = this.fillAutoCompleteTreeNodes(this.networkGraph.children[1], this.servicesTreeNodes, 'Service');
+            this.identitiesTreeNodes = this.fillAutoCompleteTreeNodes(this.networkGraph.children[2], this.identitiesTreeNodes, 'Identity');
+            this.edgeroutersTreeNodes = this.fillAutoCompleteTreeNodes(this.networkGraph.children[3], this.edgeroutersTreeNodes, 'Edge Router');
+            this.erPoliciesTreeNodes = this.fillAutoCompleteTreeNodes(this.networkGraph.children[4], this.erPoliciesTreeNodes, 'Router Policy');
+            this.serviceEdgeRouterPolicyTreeNodes = this.fillAutoCompleteTreeNodes(this.networkGraph.children[5], this.serviceEdgeRouterPolicyTreeNodes, 'Service Router Policy');
+            this.initTopoView();
+        }
+        catch (err) {
+            this.logger.error(err.message);
+        }
+        this.isLoading = false;
+    }
+    fillAutoCompleteTreeNodes(nodeObj, arr, typeName) {
+        const name = nodeObj.data.name;
+        // const id = nodeObj.data.id;
+        if (!name) {
+            return;
+        }
+        if (typeof nodeObj.data.type === 'undefined') {
+            //      //
+        }
+        else {
+            if (arr.indexOf(name) < 0 && nodeObj.data.type === typeName) {
+                arr.push(name);
+            }
+        }
+        const childNodes = nodeObj.children ? nodeObj.children : nodeObj._children;
+        for (let i = 0; childNodes && i < childNodes.length; i++) {
+            this.fillAutoCompleteTreeNodes(childNodes[i], arr, typeName);
+        }
+        return arr;
+    }
+    autocompleteSearch(event) {
+        const str = event ? event.option.value : '';
+        this.searchResourceConditionCheck(str);
+    }
+    resourceTypeChanged() {
+        this.resetSearchNode();
+        this.clearSearchLinkColors();
+        if (_.isEmpty(this.resourceType)) {
+            this.autocompleteOptions = [];
+            this.clearSearchFilter();
+            this.resourceTypeError = !_.isEmpty(this.filterText);
+            return;
+        }
+        this.filterText = '';
+        this.resourceTypeError = false;
+        if (this.resourceType === 'service-policies') {
+            this.autocompleteOptions = this.servicePoliciesTreeNodes;
+        }
+        else if (this.resourceType === 'services') {
+            this.autocompleteOptions = this.servicesTreeNodes;
+        }
+        else if (this.resourceType === 'identities') {
+            this.autocompleteOptions = this.identitiesTreeNodes;
+        }
+        else if (this.resourceType === 'edge-routers') {
+            this.autocompleteOptions = this.edgeroutersTreeNodes;
+        }
+        else if (this.resourceType === 'edge-router-policies') {
+            this.autocompleteOptions = this.erPoliciesTreeNodes;
+        }
+        else if (this.resourceType === 'service-edge-router-policies') {
+            this.autocompleteOptions = this.serviceEdgeRouterPolicyTreeNodes;
+        }
+        if (!_.isEmpty(this.filterText)) {
+            this.searchResourceConditionCheck(this.filterText);
+        }
+    }
+    searchResourceConditionCheck(searchTxt) {
+        if (this.resourceType === '' && searchTxt !== '') {
+            // if (searchTxt !== '') {
+            this.resourceTypeError = true;
+            return;
+        }
+        else {
+            this.searchResourceInTree(searchTxt);
+        }
+    }
+    searchResourceInTree(searchTxt) {
+        //  this.closeTable();
+        this.noSearchResults = false;
+        this.resourceTypeError = false;
+        this.resetTree(null);
+        if (searchTxt === '') {
+            this.clearSearchLinkColors();
+        }
+        else {
+            this.resetSearchNode();
+            this.clearSearchLinkColors();
+            let paths = [];
+            let targetNodes = [];
+            const nodeIds = [];
+            if (this.resourceType === 'service-policies') {
+                targetNodes = this.processSearchInPreorder(this.nodes[1], searchTxt, paths, targetNodes);
+            }
+            else if (this.resourceType === 'edge-routers') {
+                targetNodes = this.processSearchInPreorder(this.nodes[4], searchTxt, paths, targetNodes);
+            }
+            else if (this.resourceType === 'services') {
+                targetNodes = this.processSearchInPreorder(this.nodes[2], searchTxt, paths, targetNodes);
+            }
+            else if (this.resourceType === 'identities') {
+                targetNodes = this.processSearchInPreorder(this.nodes[3], searchTxt, paths, targetNodes);
+            }
+            else if (this.resourceType === 'edge-router-policies') {
+                targetNodes = this.processSearchInPreorder(this.nodes[5], searchTxt, paths, targetNodes);
+            }
+            else if (this.resourceType === 'service-edge-router-policies') {
+                targetNodes = this.processSearchInPreorder(this.nodes[6], searchTxt, paths, targetNodes);
+            }
+            paths = this.explorePathsForSearchedNodes(targetNodes, paths, nodeIds);
+            if (targetNodes && targetNodes.length <= 0) {
+                this.noSearchResults = true;
+                this.clearSearchLinkColors();
+                // return false;
+            }
+            else {
+                //if (targetNodes) {
+                this.openPaths(paths, true);
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                d3.selectAll('circle').filter(function (d) {
+                    const dataName = _.get(d, 'data.name', '');
+                    // const dataId = _.get(d, 'data.id', '');
+                    const nodeName = _.get(targetNodes[0], 'data.name', '');
+                    if (dataName.toLowerCase() === searchTxt.toLowerCase() && nodeName === dataName) {
+                        d3.select(this).style('fill', 'red');
+                    }
+                });
+            }
+            // else {
+            //   this.noSearchResults = true;
+            //  this.clearSearchLinkColors();
+            // }
+        }
+    }
+    explorePathsForSearchedNodes(targetNodes, paths, nodeIds) {
+        for (let i = 0; targetNodes && i < targetNodes.length; i++) {
+            let nd = targetNodes[i];
+            paths.push(nd);
+            while (nd.parent) {
+                const nodeId = _.get(nd.parent, 'data.id');
+                if (nodeIds.indexOf(nodeId) < 0) {
+                    nodeIds.push(nodeId);
+                    paths.push(nd.parent);
+                }
+                nd = nd.parent;
+            }
+        }
+        return paths;
+    }
+    processSearchInPreorder(nodeObj, searchTxt, paths, targetNodes) {
+        const name = _.get(nodeObj, 'data.name');
+        // const nodeId = _.get(nodeObj, 'data.id');
+        const isRootNode = _.get(nodeObj, 'data.rootNode');
+        if (!name) {
+            return;
+        }
+        if (isRootNode && isRootNode === 'Yes' && name.toLowerCase() === searchTxt.toLowerCase()) {
+            targetNodes.push(nodeObj);
+        }
+        const childNodes = nodeObj.children ? nodeObj.children : nodeObj._children;
+        for (let i = 0; childNodes && i < childNodes.length; i++) {
+            this.processSearchInPreorder(childNodes[i], searchTxt, paths, targetNodes);
+        }
+        return targetNodes;
+    }
+    clearSearchLinkColors() {
+        this.svg.selectAll('path.link').each(function (d) {
+            d3.select(this).style('stroke', 'white');
+        });
+        this.svg.selectAll('circle').style('fill', function (d) {
+            return d._children ? 'var(--tableText)' : '#fff';
+        });
+    }
+    openPaths(paths, doReset = false) {
+        const pathIds = [];
+        for (let i = paths.length - 1; i >= 0; i--) {
+            const l = paths[i];
+            if (this.openNodes.indexOf(l.data.id) < 0) {
+                this.openNodes.push(l.data.id);
+            }
+            this.expand(paths[i]);
+            if (i > 0) {
+                this.updateTree(l, doReset);
+            }
+            pathIds.push(l.data.id);
+        }
+        pathIds.push(paths[1].data.id);
+        pathIds.push(paths[0].data.id);
+        let childreng = null; // get 2nd level data nodes.
+        if (this.resourceType === 'service-policies') {
+            childreng = this.networkGraph.children[0];
+        }
+        else if (this.resourceType === 'services') {
+            childreng = this.networkGraph.children[1];
+        }
+        else if (this.resourceType === 'identities') {
+            childreng = this.networkGraph.children[2];
+        }
+        else if (this.resourceType === 'edge-routers') {
+            childreng = this.networkGraph.children[3];
+        }
+        else if (this.resourceType === 'edge-router-policies') {
+            childreng = this.networkGraph.children[4];
+        }
+        else if (this.resourceType === 'service-edge-router-policies') {
+            childreng = this.networkGraph.children[5];
+        }
+        const ndd_childs = childreng.children ? childreng.children : childreng._children; // 2nd level chailds. groups/childrens
+        for (let i = 0; i < ndd_childs.length; i++) {
+            // 2st level
+            //  if (this.resourceType === 'endpoints' || this.resourceType === 'services') {
+            if (ndd_childs[i].data.type === 'Group') {
+                // process groups
+                const d1 = ndd_childs[i]; //get group
+                if (d1 && paths[1].data.id === d1.data.id) {
+                    const children0 = d1.children ? d1.children : d1._children; // 3rd level childs
+                    const arr = children0.filter(function (replOb) {
+                        return replOb.data.id === paths[0].data.id;
+                    });
+                    d1.children = arr;
+                    d1._children = null;
+                    const arrgrp = ndd_childs.filter(function (replObj) {
+                        return replObj.data.id === d1.data.id;
+                    });
+                    childreng.children = arrgrp;
+                    this.updateTree(this.networkGraph, doReset);
+                    break;
+                }
+            }
+            else {
+                if (childreng.data.id === paths[1].data.id) {
+                    const arr = ndd_childs.filter(function (replOb) {
+                        return replOb.data.id === paths[0].data.id;
+                    });
+                    childreng.children = arr;
+                    childreng._children = null;
+                    this.updateTree(this.networkGraph, doReset);
+                    break;
+                }
+            }
+        }
+        let datanodes = null; // get 2nd level data nodes.
+        if (this.resourceType === 'service-policies') {
+            datanodes = this.networkGraph.data.children[0];
+        }
+        else if (this.resourceType === 'services') {
+            datanodes = this.networkGraph.data.children[1];
+        }
+        else if (this.resourceType === 'identities') {
+            datanodes = this.networkGraph.data.children[2];
+        }
+        else if (this.resourceType === 'edge-routers') {
+            datanodes = this.networkGraph.data.children[3];
+        }
+        else if (this.resourceType === 'edge-router-policies') {
+            datanodes = this.networkGraph.data.children[4];
+        }
+        else if (this.resourceType === 'service-edge-router-policies') {
+            datanodes = this.networkGraph.data.children[5];
+        }
+        if (datanodes.id === paths[1].data.id) {
+            const arr = datanodes.children.filter(function (replOb) {
+                return replOb.id === paths[0].data.id;
+            });
+            datanodes.children = arr;
+            this.updateTree(this.networkGraph, doReset);
+        }
+        else {
+            const groupNodes = datanodes.children;
+            for (let k = 0; k < groupNodes.length; k++) {
+                if (groupNodes[k].id === paths[1].data.id) {
+                    // check searched group node
+                    const arr = groupNodes[k].children.filter(function (replOb) {
+                        return replOb.id === paths[0].data.id;
+                    });
+                    groupNodes[k].children = arr;
+                    const arrgrp = groupNodes.filter(function (replObj) {
+                        return replObj.id === paths[1].data.id;
+                    });
+                    datanodes.children = arrgrp;
+                    this.updateTree(this.networkGraph, doReset);
+                    break;
+                }
+            }
+        }
+        this.updateTree(this.networkGraph, doReset);
+        this.searchRootNode = paths[1];
+        this.svg.selectAll('.link').each(function (d) {
+            if (pathIds.indexOf(d.data.id) >= 0) {
+                d3.select(this).style('stroke', 'red');
+            }
+            else {
+                d3.select(this).style('stroke', 'white');
+            }
+        });
+    }
+    resetSearchNode() {
+        if (this.searchRootNode) {
+            this.networkGraph = _.cloneDeep(this.baseNetworkGraph);
+            this.updateTree(this.networkGraph);
+        }
+    }
+    resetTree(clearSearch) {
+        this.resetSearchNode();
+        if (clearSearch) {
+            this.clearSearchFilter();
+            this.clearSearchType();
+        }
+        for (let i = this.openNodes.length - 1; i > 0; i--) {
+            const d = this.openNodes[i];
+            if (d && d.children) {
+                d._children = d.children;
+                d.children = null;
+                this.updateTree(d);
+            }
+        }
+        for (let i = this.nodes.length - 1; i > 0; i--) {
+            const d = this.nodes[i];
+            if (d && d.children) {
+                d._children = d.children;
+                d.children = null;
+                this.updateTree(d);
+            }
+        }
+        this.clearSearchLinkColors();
+        this.openNodes = [];
+        this.sizeToFit();
+        this.resetZoom();
+    }
+    expand(d) {
+        if (d._children) {
+            d.children = d._children;
+            d._children = null;
+        }
+    }
+    collapse() {
+        for (let i = this.openNodes.length - 1; i > 0; i--) {
+            const d = this.nodes[i];
+            if (d.children) {
+                d._children = d.children;
+                d.children = null;
+                this.updateTree(d);
+            }
+        }
+    }
+    filterSearchArray() {
+        if (_.isEmpty(this.resourceType)) {
+            this.autocompleteOptions = [];
+            this.resourceTypeError = !_.isEmpty(this.filterText);
+            return;
+        }
+        this.autocompleteOptions = [];
+        if (this.resourceType === 'service-policies') {
+            this.autocompleteOptions = this.servicePoliciesTreeNodes.filter((option) => option.toLowerCase().includes(this.filterText.toLowerCase()));
+        }
+        else if (this.resourceType === 'services') {
+            this.autocompleteOptions = this.servicesTreeNodes.filter((option) => option.toLowerCase().includes(this.filterText.toLowerCase()));
+        }
+        else if (this.resourceType === 'identities') {
+            this.autocompleteOptions = this.identitiesTreeNodes.filter((option) => option.toLowerCase().includes(this.filterText.toLowerCase()));
+        }
+        else if (this.resourceType === 'edge-routers') {
+            this.autocompleteOptions = this.edgeroutersTreeNodes.filter((option) => option.toLowerCase().includes(this.filterText.toLowerCase()));
+        }
+        else if (this.resourceType === 'edge-router-policies') {
+            this.autocompleteOptions = this.erPoliciesTreeNodes.filter((option) => option.toLowerCase().includes(this.filterText.toLowerCase()));
+        }
+        else if (this.resourceType === 'service-edge-router-policies') {
+            this.autocompleteOptions = this.serviceEdgeRouterPolicyTreeNodes.filter((option) => option.toLowerCase().includes(this.filterText.toLowerCase()));
+        }
+    }
+    zoomIn() {
+    }
+    zoomOut() {
+    }
+    clearSearchFilter() {
+        this.resourceTypeError = false;
+        this.filterText = '';
+        this.filterSearchArray();
+        this.resetSearchNode();
+        this.collapse();
+        this.clearSearchLinkColors();
+    }
+    clearSearchType() {
+        this.resourceType = '';
+        this.autocompleteOptions = [];
+    }
+    resetZoom() {
+        // const currentZoom = this.getZoomScale();
+        const transform = this.transform || _.cloneDeep(d3.zoomIdentity);
+        transform.k = 1;
+        this.svg.attr('transform', transform);
+    }
+    initTopoView() {
+        this.autocompleteOptions = [];
+        const margin = { top: 20, right: 190, bottom: 30, left: 0 };
+        // const width = 1600 - margin.left - margin.right;
+        const width = window.innerWidth - margin.right;
+        // const height = 1600 - margin.top - margin.bottom;
+        const height = window.innerHeight - margin.bottom;
+        this.treetooltip = d3.select('#tooltip');
+        this.resourceTypeError = false;
+        this.filterText = '';
+        this.resourceType = '';
+        const handleZoom = (e) => {
+            this.svg.attr('transform', e.transform);
+        };
+        this.zoom = d3.zoom().on('zoom', handleZoom);
+        this.svg = d3
+            .select('#NetworkVisualizerSVG')
+            .attr('width', '100%')
+            .attr('height', '100%')
+            .call(this.zoom)
+            .attr('viewBox', '-20 -450 ' + (width - margin.top * 2 - margin.bottom) + ' ' + +(height * 2 - margin.bottom))
+            .append('g')
+            .attr('transform', 'translate(' + -20 + ',' + 200 + ')');
+        d3.select('body').on('click', function () {
+            d3.select('#topocontextmenu').style('display', 'none');
+        });
+        d3.selectAll('g > *').remove();
+        this.treemap = d3.tree().nodeSize([100, 20]);
+        this.networkGraph.x = 100; // height / 4;
+        this.networkGraph.y = 100;
+        this.networkGraph.children.forEach(collapse);
+        this.updateTree(this.networkGraph);
+        _.delay(() => {
+            this.transform = d3.zoomIdentity;
+            this.transform.x = -200;
+            this.transform.y = 205;
+            this.transform.k = 1;
+            this.svg.transition().duration(750).attr('transform', this.transform);
+        }, 600);
+        function collapse(d) {
+            if (d.data.rootNode === 'Yes') {
+                d.data.clickProcess = 'Not Yet';
+                d._children = null;
+            }
+            if (d.children) {
+                d._children = d.children;
+                d._children.forEach(collapse);
+                d.children = null;
+            }
+        }
+    }
+    updateTree(source, doReset = false) {
+        if (doReset) {
+            d3.selectAll('g > *').remove();
+        }
+        const duration = 750;
+        try {
+            this.treeData = this.treemap(this.networkGraph);
+            this.nodes = this.treeData.descendants();
+            this.links = this.treeData.descendants().slice(1);
+        }
+        catch (e) {
+            this.logger.error('Error in building tree object: ' + e.message);
+        }
+        const svgDefs = this.svg.append('defs');
+        const linearGradient = svgDefs.append('linearGradient').attr('id', 'NodeGradient');
+        linearGradient.append('stop').attr('class', 'stop1').attr('offset', '0%');
+        linearGradient.append('stop').attr('class', 'stop2').attr('offset', '50%');
+        linearGradient.append('stop').attr('class', 'stop3').attr('offset', '100%');
+        const linearGradient2 = svgDefs.append('linearGradient').attr('id', 'NodeHoverGradient');
+        linearGradient2.append('stop').attr('class', 'stop1a').attr('offset', '0%');
+        linearGradient2.append('stop').attr('class', 'stop2a').attr('offset', '50%');
+        linearGradient2.append('stop').attr('class', 'stop3a').attr('offset', '100%');
+        this.nodes.forEach(function (d) {
+            d.y = d.depth * 400;
+        });
+        this.node = this.svg.selectAll('g.node').data(this.nodes, function (d) {
+            return d.data.id;
+        });
+        this.nodeEnter = this.node
+            .enter()
+            .append('g')
+            .attr('class', (d) => {
+            let className = '';
+            if (_.startsWith(d.data.name, 'Edge Routers') || _.includes(d.data.type, 'Edge Router')) {
+                className = 'edge-router';
+            }
+            if (_.includes(d.data.name, 'Identities') || _.includes(d.data.type, 'Identity')) {
+                className = 'endpoint';
+            }
+            if (_.startsWith(d.data.name, 'Services') || _.startsWith(d.data.type, 'Service')) {
+                className = 'service';
+            }
+            if (_.startsWith(d.data.name, 'Bind-Services') || _.startsWith(d.data.name, 'Dial-Services')) {
+                className = 'service';
+            }
+            if (_.startsWith(d.data.name, 'BindPolicies') || _.startsWith(d.data.name, 'DialPolicies') || _.startsWith(d.data.name, 'BindPolicy')) {
+                className = 'service-policy';
+            }
+            if (_.includes(d.data.name, 'Service Policies') || _.includes(d.data.type, 'ServicePolicy')) {
+                className = 'service-policy';
+            }
+            if (_.startsWith(d.data.name, 'Edge Router Policies') || _.startsWith(d.data.type, 'Router Policy')) {
+                className = 'edge-router-policy';
+            }
+            if (_.startsWith(d.data.name, 'Service Edge Router Policies') ||
+                _.startsWith(d.data.type, 'Service Router Policy')) {
+                className = 'service-edge-router-policy';
+            }
+            className = d._children ? 'node ' + className : 'node terminate ' + className;
+            return className;
+        })
+            .attr('transform', function (d) {
+            if (source && source.x) {
+                return 'translate(' + source.y + ',' + source.x + ')';
+            }
+            else {
+                return 'translate(' + d.y + ',' + d.x + ')';
+            }
+        });
+        this.nodeEnter.on('contextmenu', (event, d) => {
+            event.preventDefault();
+            d3.select('#tooltip').style('display', 'none');
+            const nw = this.currentNetwork;
+            const rawEdgerouters = this.edgerouters;
+            const rawEndpoints = this.identities;
+            const rawAppwans = this.service_policies;
+            const edgeRouterPolicies = this.router_policies;
+            if (d && d.data && d.data.contextMenu === 'Yes') {
+                d3.select('#topocontextmenu')
+                    .style('position', 'absolute')
+                    .style('left', event.offsetX + 'px')
+                    .style('top', event.offsetY + 'px')
+                    .style('display', 'block');
+            }
+            else {
+                return;
+            }
+            let obj = null;
+            if (d && d.data && d.data.type === 'Identity') {
+                if (d.data.status === "Registered") {
+                    enableLi('#liSingleUT');
+                    enableLi('#liFLSingleRouter');
+                    enableLi('#liSingleLT');
+                }
+                else {
+                    disableLi('#liSingleUT');
+                    disableLi('#liFLSingleRouter');
+                    disableLi('#liSingleLT');
+                }
+                enableLi('#liMet');
+                enableLi('#liVC');
+                enableLi('#liEV');
+                disableLi('#liIns');
+                disableLi('#liAL');
+                disableLi('#liEPs');
+                disableLi('#liFLAll');
+                disableLi('#liFLSingleRouter');
+                disableLi('#liSingleLT');
+                disableLi('#liCL');
+                disableLi('#liLT');
+                /*
+                obj = new Identity();
+                for (let i = 0; i < rawEndpoints.length; i++) {
+                    if (rawEndpoints[i].id === d.data.uuid) {
+                        obj = rawEndpoints[i];
+                    }
+                }
+                */
+                this.contextmenuNodeType = 'identity';
+            }
+            else if (d && d.data && d.data.type === 'Edge Router') {
+                if (d.data.status === "PROVISIONED") {
+                    enableLi('#liSingleUT');
+                    enableLi('#liFLSingleRouter');
+                    enableLi('#liSingleLT');
+                }
+                else {
+                    disableLi('#liSingleUT');
+                    disableLi('#liFLSingleRouter');
+                    disableLi('#liSingleLT');
+                }
+                enableLi('#liMet');
+                enableLi('#liVC');
+                disableLi('#liIns');
+                disableLi('#liEV');
+                enableLi('#liAL');
+                disableLi('#liEPs');
+                disableLi('#liFLAll');
+                disableLi('#liCL');
+                disableLi('#liLT');
+                this.contextmenuNodeType = 'edge-router';
+                /*
+                obj = new EdgeRouterV2();
+                for (let i = 0; i < rawEdgerouters.length; i++) {
+                    if (rawEdgerouters[i].id === d.data.uuid) {
+                        obj = rawEdgerouters[i];
+                    }
+                }
+                */
+            }
+            else if (d && d.data && d.data.type === 'Service') {
+                enableLi('#liMet');
+                enableLi('#liVC');
+                disableLi('#liIns');
+                disableLi('#liEV');
+                disableLi('#liAL');
+                enableLi('#liEPs');
+                disableLi('#liFLAll');
+                disableLi('#liFLSingleRouter');
+                disableLi('#liSingleLT');
+                disableLi('#liCL');
+                disableLi('#liLT');
+                enableLi('#liSingleUT');
+                this.contextmenuNodeType = 'service';
+                /*
+                obj = new PlatformService();
+                for (let i = 0; i < this.services.length; i++) {
+                    if (this.services[i].id === d.data.uuid) {
+                        obj = this.services[i];
+                    }
+                }
+                */
+            }
+            else if (d && d.data && d.data.type === 'AppWAN') {
+                disableLi('#liMet');
+                enableLi('#liVC');
+                disableLi('#liIns');
+                disableLi('#liEV');
+                disableLi('#liAL');
+                disableLi('#liEPs');
+                disableLi('#liFLAll');
+                disableLi('#liFLSingleRouter');
+                disableLi('#liSingleLT');
+                disableLi('#liCL');
+                disableLi('#liLT');
+                disableLi('#liSingleUT');
+                /*
+                obj = new ServicePolicy();
+                for (let i = 0; i < rawAppwans.length; i++) {
+                    if (rawAppwans[i].id === d.data.uuid) {
+                        obj = rawAppwans[i];
+                    }
+                }
+                */
+                this.contextmenuNodeType = 'appwan';
+            }
+            else if (d && d.data && d.data.type === 'Router Policy') {
+                disableLi('#liMet');
+                disableLi('#liIns');
+                enableLi('#liVC');
+                disableLi('#liEV');
+                disableLi('#liAL');
+                disableLi('#liEPs');
+                disableLi('#liFLSingleRouter');
+                disableLi('#liSingleLT');
+                disableLi('#liFLAll');
+                disableLi('#liCL');
+                disableLi('#liLT');
+                disableLi('#liSingleUT');
+                this.contextmenuNodeType = 'router-policy';
+                /*
+                 obj = new EdgeRouterPolicyV2();
+                   for (let i = 0; i < edgeRouterPolicies.length; i++) {
+                       if (edgeRouterPolicies[i].id === d.data.uuid) {
+                           obj = edgeRouterPolicies[i];
+                       }
+                   }
+                 */
+            }
+            else if (d && d.data && d.data.type === 'Network') {
+                enableLi('#liMet');
+                disableLi('#liIns');
+                enableLi('#liVC');
+                disableLi('#liEV');
+                enableLi('#liAL');
+                disableLi('#liEPs');
+                enableLi('#liFLAll');
+                disableLi('#liFLSingleRouter');
+                disableLi('#liSingleLT');
+                enableLi('#liCL');
+                enableLi('#liLT');
+                disableLi('#liSingleUT');
+                this.contextmenuNodeType = 'network';
+                obj = nw;
+            }
+            else if (d && d.data && d.data.type === 'Service Router Policy') {
+                disableLi('#liMet');
+                disableLi('#liIns');
+                enableLi('#liVC');
+                disableLi('#liEV');
+                disableLi('#liAL');
+                disableLi('#liEPs');
+                disableLi('#liFLAll');
+                disableLi('#liFLSingleRouter');
+                disableLi('#liSingleLT');
+                disableLi('#liCL');
+                disableLi('#liLT');
+                disableLi('#liSingleUT');
+                this.contextmenuNodeType = 'service-router-policy';
+                /*
+                 obj = new ServiceEdgeRouterPolicy();
+                 for (let i = 0; i < this.service_router_policies.length; i++) {
+                     if (this.service_router_policies[i].id === d.data.uuid) {
+                         obj = this.service_router_policies[i];
+                     }
+                 }
+                 */
+            }
+            this.contextmenuNode = obj;
+            d3.select('#tooltip').style('display', 'none');
+        });
+        this.circles = this.nodeEnter
+            .append('circle')
+            .attr('class', 'node')
+            .attr('r', 10)
+            .style('fill', function (d) {
+            return d._children ? 'var(--tableText)' : '#fff';
+        })
+            .on('mousemove', (event, source) => {
+            this.drawTreeTooltip(event, source);
+        })
+            .on('mouseout', this.removeTreeTooltip)
+            .on('contextmenu', (event) => {
+            event.preventDefault();
+        })
+            .on('click', async (event, d) => {
+            if (d && d.data && d.data.contextMenu === 'Yes') {
+                d3.select('#topocontextmenu').style('display', 'none');
+            }
+            d3.select('#tooltip').style('display', 'none');
+            if (d.children && d.children.length > 0) {
+                const index = this.openNodes.indexOf(d.data.id, 0);
+                if (index > -1) {
+                    this.openNodes.splice(index, 1);
+                }
+                d._children = d.children;
+                d.children = null;
+            }
+            else {
+                if (this.openNodes.indexOf(d.data.id) < 0) {
+                    this.openNodes.push(d.data.id);
+                }
+                if (d.data.clickProcess === 'Not Yet') {
+                    d._children = null;
+                    if (d.data &&
+                        d.data.rootNode &&
+                        d.data.rootNode === 'Yes' &&
+                        d.data.type === 'Identity' &&
+                        !d.children &&
+                        !d._children) {
+                        const arr = await this.treeNodeProcessor.processIdentitiesForNodeClick(d, this.networkGraph, this.identities, this.uniqId, this.zitiService, this.configs);
+                        this.uniqId = arr[1];
+                        this.networkGraph = arr[0];
+                        d.data.clickProcess = 'Completed';
+                        this.networkGraph.children.find((nd) => {
+                            collapseFew(nd, this.openNodes);
+                        });
+                        this.updateTree(d);
+                    }
+                    else if (d.data &&
+                        d.data.rootNode &&
+                        d.data.rootNode === 'Yes' &&
+                        d.data.type === 'Service' &&
+                        !d.children &&
+                        !d._children) {
+                        const arr = await this.treeNodeProcessor.processServicesForNodeClick(d, this.networkGraph, this.services, this.uniqId, this.zitiService);
+                        this.uniqId = arr[1];
+                        this.networkGraph = arr[0];
+                        d.data.clickProcess = 'Completed';
+                        this.networkGraph.children.find((nd) => {
+                            collapseFew(nd, this.openNodes);
+                        });
+                        this.updateTree(d);
+                    }
+                    else if (d.data &&
+                        d.data.rootNode &&
+                        d.data.rootNode === 'Yes' &&
+                        d.data.type === 'ServicePolicy' &&
+                        !d.children &&
+                        !d._children) {
+                        const arr = await this.treeNodeProcessor.processServicePoliciesForNodeClick(d, this.networkGraph, this.service_policies, this.uniqId, this.zitiService);
+                        this.uniqId = arr[1];
+                        this.networkGraph = arr[0];
+                        d.data.clickProcess = 'Completed';
+                        this.networkGraph.children.find((nd) => {
+                            collapseFew(nd, this.openNodes);
+                        });
+                        this.updateTree(d);
+                    }
+                    else if (d.data &&
+                        d.data.rootNode &&
+                        d.data.rootNode === 'Yes' &&
+                        d.data.type === 'Edge Router' &&
+                        !d.children &&
+                        !d._children) {
+                        const arr = await this.treeNodeProcessor.processEdgeroutersForNodeClick(d, this.networkGraph, this.edgerouters, this.uniqId, this.zitiService);
+                        this.uniqId = arr[1];
+                        this.networkGraph = arr[0];
+                        d.data.clickProcess = 'Completed';
+                        this.networkGraph.children.find((nd) => {
+                            collapseFew(nd, this.openNodes);
+                        });
+                        this.updateTree(d);
+                    }
+                    else if (d.data &&
+                        d.data.rootNode &&
+                        d.data.rootNode === 'Yes' &&
+                        d.data.type === 'Router Policy' &&
+                        !d.children &&
+                        !d._children) {
+                        const arr = await this.treeNodeProcessor.processEdgeRouterPoliciesForNodeClick(d, this.networkGraph, this.router_policies, this.uniqId, this.zitiService);
+                        this.uniqId = arr[1];
+                        this.networkGraph = arr[0];
+                        d.data.clickProcess = 'Completed';
+                        this.networkGraph.children.find((nd) => {
+                            collapseFew(nd, this.openNodes);
+                        });
+                        this.updateTree(d);
+                    }
+                    else if (d.data &&
+                        d.data.rootNode &&
+                        d.data.rootNode === 'Yes' &&
+                        d.data.type === 'Service Router Policy' &&
+                        !d.children &&
+                        !d._children) {
+                        const arr = await this.treeNodeProcessor.processServiceEdgeRouterPoliciesForNodeClick(d, this.networkGraph, this.service_router_policies, this.uniqId, this.zitiService);
+                        this.uniqId = arr[1];
+                        this.networkGraph = arr[0];
+                        d.data.clickProcess = 'Completed';
+                        this.networkGraph.children.find((nd) => {
+                            collapseFew(nd, this.openNodes);
+                        });
+                        this.updateTree(d);
+                    }
+                    else {
+                        d.children = d._children;
+                    }
+                }
+                else {
+                    d.children = d._children;
+                }
+                if (d._children) {
+                    d._children = null;
+                }
+            }
+            if (d.children || d._children) {
+                this.updateTree(d);
+            }
+            const rootNode = _.get(d, 'data.children[0].rootNode', '');
+            const subrootNode = _.get(d, 'data.rootNode', '');
+            if (rootNode === 'Yes' || subrootNode === 'Yes') {
+                rootNodeisYesColorChange();
+            }
+        });
+        this.nodeEnter
+            .append('foreignObject')
+            .attr('height', '50')
+            .attr('width', '330')
+            .attr('x', '10')
+            .attr('y', '-25')
+            .append('xhtml:body')
+            .style('background', 'transparent')
+            .html(function (d) {
+            return `<div class="text-container"<span>${d.data.name}</span>`;
+        });
+        this.nodeUpdate = this.nodeEnter.merge(this.node);
+        this.nodeUpdate
+            .transition()
+            .duration(duration)
+            .attr('transform', function (d) {
+            return 'translate(' + d.y + ',' + d.x + ')';
+        });
+        this.nodeUpdate.select('circle.node').attr('r', 18).attr('cursor', 'pointer');
+        this.nodeExit = this.node
+            .exit()
+            .transition()
+            .duration(duration)
+            .attr('transform', function (d) {
+            if (source && source.x) {
+                return 'translate(' + source.y + ',' + source.x + ')';
+            }
+            else {
+                return 'translate(' + d.y + ',' + d.x + ')';
+            }
+        })
+            .remove();
+        this.nodeExit.select('circle').attr('r', 0);
+        this.nodeExit.select('text').style('fill-opacity', 10);
+        this.link = this.svg.selectAll('path.link').data(this.links, function (d) {
+            return d.data.id;
+        });
+        this.linkUpdate = this.link
+            .enter()
+            .insert('path', 'g')
+            .attr('class', 'link')
+            .attr('d', function (d) {
+            let o;
+            if (source && source.x) {
+                o = { x: source.x, y: source.y };
+            }
+            else {
+                o = { x: d.x, y: d.y };
+            }
+            return diagonal(o, o, '1');
+        })
+            .merge(this.link);
+        this.linkUpdate
+            .transition()
+            .duration(duration)
+            .attr('d', function (d) {
+            return diagonal(d, d.parent, '2');
+        });
+        this.linkExit = this.link
+            .exit()
+            .transition()
+            .duration(duration)
+            .attr('d', function (d) {
+            let o;
+            if (source && source.x) {
+                o = { x: source.x, y: source.y };
+            }
+            else {
+                o = { x: d.x, y: d.y };
+            }
+            return diagonal(o, o, '3');
+        })
+            .remove();
+        this.nodes.forEach(function (d) {
+            d.x0 = d.x;
+            d.y0 = d.y;
+        });
+        function disableLi(liId) {
+            d3.select(liId).style('display', 'none');
+        }
+        function enableLi(liId) {
+            d3.select(liId).style('display', 'block');
+        }
+        function diagonal(s, d, lg) {
+            const path = `M ${s.y} ${s.x}
+             C ${(s.y + d.y) / 2} ${s.x},
+               ${(s.y + d.y) / 2} ${d.x},
+               ${d.y} ${d.x}`;
+            return path;
+        }
+        function rootNodeisYesColorChange() {
+            d3.selectAll('circle').each(function (d) {
+                const rootNode = _.get(d, 'data.rootNode', '');
+                const clickProcess = _.get(d, 'data.clickProcess', '');
+                if (rootNode === 'Yes' && clickProcess === 'Not Yet') {
+                    d3.select(this).style('fill', 'brown');
+                }
+                else if (rootNode === 'Yes' && clickProcess !== 'Not Yet') {
+                    const color = d._children ? 'var(--tableText)' : '#fff';
+                    d3.select(this).style('fill', color);
+                }
+            });
+        }
+        function collapseDepth(d, id) {
+            // unused
+            if (d.children) {
+                if (d.data.id !== id) {
+                    d._children = d.children;
+                    d._children.forEach(collapseDepth);
+                    d.children = null;
+                }
+                else {
+                    d.children.forEach(collapseDepth);
+                }
+            }
+        }
+        function collapseFew(_nd, openNodes) {
+            if (_nd.data.id === '#all') {
+                return;
+            }
+            if (_nd.data.rootNode === 'Yes' && _nd.data.clickProcess === 'Not Yet') {
+                _nd._children = [];
+            }
+            if (_nd.children && openNodes.indexOf(_nd.data.id) < 0) {
+                _nd._children = _nd.children;
+                if (_nd._children)
+                    _nd._children.find((_nd) => {
+                        collapseFew(_nd, openNodes);
+                    });
+                _nd.children = null;
+            }
+            if (_nd.children && openNodes.indexOf(_nd.data.id) >= 0) {
+                if (_nd.children)
+                    _nd.children.find((_nd) => {
+                        collapseFew(_nd, openNodes);
+                    });
+            }
+        }
+        if (source.children === null) {
+            _.delay(this.sizeToFit.bind(this), 650);
+        }
+    } // end of updateTree
+    sizeToFit() {
+        const boundingBox = this.svg._groups[0][0].getBoundingClientRect();
+        const bottomDelta = boundingBox.height - 100 - -boundingBox.top;
+        const topDelta = boundingBox.height + 500 - boundingBox.bottom;
+        const topOutOfView = topDelta < 0;
+        const bottomOutOfView = bottomDelta < 0;
+        if (bottomOutOfView || topOutOfView) {
+            const trans = this.transform;
+            trans.y = topOutOfView ? 400 : 0;
+            this.svg.transition().duration(750).attr('transform', trans);
+        }
+    }
+    removeGraphTooltip() {
+        if (this.graphtooltip) {
+            this.graphtooltip.style('display', 'none');
+        }
+    }
+    drawGraphTooltip(event, d) {
+        document.getElementById('tooltip').innerHTML = this.readGraphKeyValues(d);
+        this.graphtooltip.style('display', 'block');
+        const x = event.pageX - 400 + 'px';
+        const y = event.pageY + 10 + 'px';
+        this.graphtooltip.style('left', x);
+        this.graphtooltip.style('top', y);
+    }
+    readGraphKeyValues(d) {
+        let info = '<span style="font-size:14px;font-family:Open Sans; font-weight: 600; font-color: var(--tableText);">';
+        const keys = Object.keys(d.data);
+        keys.forEach((k) => {
+            if (k === 'value' ||
+                k === 'group' ||
+                k === 'index' ||
+                k === 'parent' ||
+                k === 'depth' ||
+                k === 'x' ||
+                k === 'y' ||
+                k === 'id' ||
+                k === 'x0' ||
+                k === 'y0' ||
+                k === 'vy' ||
+                k === 'vx') {
+                // continue;
+            }
+            else if (k === 'children') {
+                const kVal = d.data[k];
+                info = info + '  ' + k + '  :  ' + kVal.length + '<br>';
+            }
+            else {
+                if (this.isAnObject(d.data[k])) {
+                    const kVal = d.data[k];
+                    info = info + '   ' + k + '  :  ' + kVal.name + '<br>';
+                }
+                else {
+                    const vo = d.data[k];
+                    info = info + '   ' + k + '  :  ' + (vo !== null || vo !== '' ? d.data[k] : 'N/A') + '<br>';
+                }
+            }
+        });
+        return info + '</span>';
+    }
+    setColor(d) {
+        if (d.status === 'Error' && d.group === 3) {
+            return 'red';
+        }
+        else if (d.status !== 'Error' && d.group === 3) {
+            return 'var(--tableText)';
+        }
+        else {
+            return 'var(--tableText)';
+        }
+    }
+    ticked() {
+        this.links
+            .attr('x1', function (d) {
+            return d.source.x;
+        })
+            .attr('y1', function (d) {
+            return d.source.y;
+        })
+            .attr('x2', function (d) {
+            return d.target.x;
+        })
+            .attr('y2', function (d) {
+            return d.target.y;
+        });
+        this.nodes.attr('transform', function (d) {
+            return 'translate(' + d.x + ',' + d.y + ')';
+        });
+    }
+    isAnObject(o) {
+        return o instanceof Object && o.constructor === Object;
+    }
+    readObjectValues(linkObject) {
+        let info = '<span style="font-size:12px;font-family: sans-serif">';
+        const keys = Object.keys(linkObject.data);
+        keys.forEach((k) => {
+            if (this.isAnObject(linkObject.data[k])) {
+                const kVal = linkObject.data[k];
+                info = info + '   ' + k + '  :  ' + kVal.id + '<br>';
+            }
+            else {
+                info = info + '   ' + k + '  :  ' + linkObject.data[k] + '<br>';
+            }
+        });
+        return info + '</span>';
+    }
+    nodeColor(d) {
+        if (d.status === 'Error') {
+            return '#FF0000';
+        }
+        else {
+            return 'blue';
+        }
+    }
+    nodeshape(d) {
+        if (d.group === '3') {
+            return 'rect';
+        }
+        else {
+            return 'circle';
+        }
+    }
+    linkWidth(d) {
+        if (d.group === 1) {
+            return 10;
+        }
+        else {
+            return 2;
+        }
+    }
+    dragstarted(event, d) {
+        if (!event.active) {
+            this.simulation.alphaTarget(0.3).restart();
+        }
+        d.fx = d.x;
+        d.fy = d.y;
+    }
+    dragged(d) {
+        d.fx = d.x;
+        d.fy = d.y;
+    }
+    dragended(event, d) {
+        if (!event.active) {
+            this.simulation.alphaTarget(0);
+        }
+        d.fx = null;
+        d.fy = null;
+    }
+    removeTreeTooltip() {
+        this.treetooltip = d3.select('#tooltip');
+        if (this.treetooltip) {
+            this.treetooltip.style('display', 'none');
+        }
+    }
+    drawTreeTooltip(event, s) {
+        this.treetooltip = d3.select('#tooltip');
+        this.treetooltip.style('display', 'block');
+        const x = event.pageX + 'px';
+        const y = event.pageY + 15 + 'px';
+        this.treetooltip.style('left', x);
+        this.treetooltip.style('top', y);
+        document.getElementById('tooltip').innerHTML = this.readTreeKeyValues(event, s);
+    }
+    readTreeKeyValues(event, d) {
+        let info = '<span>';
+        const keys = Object.keys(d.data); // mp.keys();
+        keys.forEach(function (k) {
+            if (k === 'protocol' ||
+                k === 'contextMenu' ||
+                k === 'uuid' ||
+                k === 'lastId' ||
+                k === 'clickProcess' ||
+                k === 'rootNode' ||
+                k === 'id' ||
+                k === 'children' ||
+                k === 'parent' ||
+                k === 'depth' ||
+                k === 'x' ||
+                k === 'y' ||
+                k === 'rootNode' ||
+                k === 'x0' ||
+                k === 'y0') {
+                // continue;
+            }
+            else {
+                info = info + '   ' + k + '  :  ' + d.data[k] + '<br>';
+            }
+        });
+        return info + '</span>';
+    }
+    hide() { }
+    toggleModalSize() { }
+    ;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NetworkVisualizerComponent, deps: [{ token: SETTINGS_SERVICE }, { token: ZITI_DATA_SERVICE }, { token: i1.HttpClient }, { token: i2.LoggerService }, { token: i3.TreeNodeProcessor }, { token: i4.NetworkVisualizerHelper }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: NetworkVisualizerComponent, selector: "app-network-visualizer", usesInheritance: true, ngImport: i0, template: "<div class=\"ziti-page-container ziti-identities-container\">\n\n    <div class=\"nf-network-topology-container\" >\n\n      <div class=\"css-header\">{{title}} </div><br>\n\n      <div  class=\"nf-net-vis-controls-header\">\n        <div class=\"nf-topology-zoom-container\">\n          <!--button (click)=\"zoomOut()\" class=\"nf-topology-zoom-button minus\"></button>\n          <button (click)=\"zoomIn()\" class=\"nf-topology-zoom-button plus\"></button-->\n          <div (click)=\"resetTree('Yes')\" class=\"reset-button\" title=\"Reset\"></div>\n        </div>\n        <select\n            (change)=\"resourceTypeChanged()\"\n            [(ngModel)]=\"resourceType\"\n            [ngClass]=\"{ 'resource-type-error': resourceTypeError }\"\n            class=\"resource-type-select\"\n            id=\"ResourceTypeSelect\"\n        >\n          <option value=\"\">Select Resource Type</option>\n          <option value=\"service-policies\">Service Policies</option>\n          <option value=\"services\">Services</option>\n          <option value=\"identities\">Identities</option>\n          <option value=\"edge-routers\">Edge Routers</option>\n          <option value=\"edge-router-policies\">Edge Router Policies</option>\n          <option value=\"service-edge-router-policies\">Service Edge Router Policies</option>\n        </select>\n        <div class=\"nf-net-vis-filter-container listBox row\">\n          <input\n              (keyup)=\"filterSearchArray()\"\n              [(ngModel)]=\"filterText\"\n              [matAutocomplete]=\"auto\"\n              class=\"nf-topology-filter-input\"\n              id=\"filterText\"\n              matInput\n              placeholder=\"Type to Filter\"\n          />\n\n          <div\n              (click)=\"clearSearchFilter()\"\n              *ngIf=\"filterText !== ''\"\n              class=\"buttonBall close\"\n              id=\"ClearSearchFilter\"\n          ></div>\n          <div [hidden]=\"!noSearchResults\" class=\"no-results-warning\">No Results Found</div>\n          <mat-autocomplete #auto=\"matAutocomplete\" (optionSelected)=\"autocompleteSearch($event)\">\n            <mat-option *ngFor=\"let option of autocompleteOptions\" [value]=\"option\">\n              {{ option }}\n            </mat-option>\n          </mat-autocomplete>\n        </div>\n      </div>\n\n      <div class=\"nf-topology-legend\">\n        <div class=\"legend-item\">\n          <div class=\"legend-circle servicepolicies\"></div>\n          <div class=\"legend-text\">Service Policies</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle services\"></div>\n          <div class=\"legend-text\">Services</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle endpoints\"></div>\n          <div class=\"legend-text\">Identities</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle edgerouters\"></div>\n          <div class=\"legend-text\">Edge Routers</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle erpolicies\"></div>\n          <div class=\"legend-text\">Edge Router Policies</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle serviceerpolicies\"></div>\n          <div class=\"legend-text\">Service Router Policies</div>\n        </div>\n      </div>\n\n      <div class=\"topotip\" id=\"tooltip\"></div>\n      <svg style='pointer-events:all' id=\"NetworkVisualizerSVG\"></svg>\n      <lib-loading-indicator *ngIf=\"isLoading\" [isLoading]=\"isLoading\"></lib-loading-indicator>\n    </div>\n\n</div>\n", styles: [".ziti-page-container{height:100%;width:100%;left:0;display:flex;flex-direction:column;position:absolute;padding-top:1px;padding-left:3px;padding-right:3px;top:0}.nf-network-topology-container{overflow:hidden;width:100%;height:100%;background-color:var(--background);z-index:1001;margin:auto;inset:0;padding-top:1px;padding-left:3px;padding-right:3px;background:#f5e9f2;background-image:linear-gradient(#ecd3e6 2px,transparent 0),linear-gradient(90deg,#ecd3e6 2px,transparent 0),linear-gradient(#ecd3e6 1px,transparent 0),linear-gradient(90deg,#ecd3e6 1px,transparent 0);background-size:40px 40px,40px 40px,10px 10px,10px 10px}.css-header{height:50px;font-size:25px;font-weight:600;margin:8px 0 0 2px;font-family:Russo One;color:#0027ab;font-size:30px;text-transform:uppercase;font-weight:400;background-color:transparent}.resource-type-select{width:230px;flex-shrink:0;border-radius:27px;height:51px;margin-top:20px;margin-left:20px;-webkit-backdrop-filter:saturate(110%) blur(15px);backdrop-filter:saturate(110%) blur(15px);background-color:#ffffff80!important;border-color:var(--navigation);box-shadow:0 20px 23px 0 var(--shadow);color:var(--tableText);padding-left:20px}select{background-image:url(/assets/svgs/ArrowDown.svg);background-position:center right 18px;background-repeat:no-repeat;background-size:18px;padding-right:38px}.no-results-warning{bottom:-20px;left:20px;font-size:15px;color:var(--tableText);padding-left:20px;padding-top:5px}.resource-type-error{border-width:3px;border-color:var(--red)!important}.nf-links{stroke:#fff;stroke-opacity:1.6}.nf-net-vis-controls-header{display:flex;flex-direction:row;position:absolute;z-index:99999;flex:1 0 auto;top:50px}.nf-net-vis-filter-container{max-width:300px;margin-top:20px;margin-left:10px;flex:1 0 auto}.table-filter-container{max-width:300px;margin-top:0;margin-left:1px;flex:1 0 auto}#ClearSearchFilter{position:absolute;right:2px;top:2px;width:20px;height:20px;font-size:25px;color:var(--tableText);z-index:99999999}#popupTableTitle{width:100%;font-weight:900;display:inline-block;background-color:var(--navigation);box-shadow:0 20px 23px 0 var(--shadow);border:2px #d3d3d3!important;text-align:center;border:2px;border-color:#d3d3d3;height:25px;top:2px;color:#fff;padding-right:5px;background:#000;cursor:move}#tra:hover{text-decoration:underline}#CloseDataTable{position:absolute;right:5px;top:-33px;width:25px;height:25px;font-size:15px;color:#fff;z-index:99999999}.copydatatable{width:135px;height:17px;font-size:10pt;font-family:tahoma;top:95%;right:0%;border-radius:5px;background:#fff;border:0px solid gray!important;position:absolute!important;text-transform:uppercase;cursor:pointer;z-index:999}.copydatatable:hover{text-decoration:underline}.nf-topology-filter-input{height:50px;border-radius:25px;border-color:var(--navigation);background-color:var(--navigation);box-shadow:0 20px 23px 0 var(--shadow);padding-left:20px;padding-right:35px}.nf-topology-select-container{max-width:400px;margin-top:20px;margin-left:20px;flex:1 0 auto}.nf-topology-select-input{height:45px;border-radius:25px;border-color:var(--navigation);background-color:var(--navigation);box-shadow:0 20px 23px 0 var(--shadow);padding-left:20px}input:focus,textarea:focus,select:focus{box-shadow:0 20px 23px 0 var(--shadow)}@supports ((-webkit-backdrop-filter: saturate(110%) blur(15px)) or (backdrop-filter: saturate(110%) blur(15px))){.nf-topology-filter-input{background:var(--glass)!important;-webkit-backdrop-filter:saturate(110%) blur(15px);backdrop-filter:saturate(110%) blur(15px)}}.nf-topology-zoom-container{display:flex;margin-left:20px;margin-top:20px;flex:1 0 auto}.nf-topology-zoom-button.minus{height:50px;width:50px;margin-right:10px;border-radius:55px;border:unset;font-size:40px;font-family:icomoon!important;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;text-align:center;color:var(--primaryColor);line-height:49px;background-color:var(--navigation);cursor:pointer;overflow:hidden;z-index:24;box-shadow:0 20px 23px 0 var(--shadow);transition:background-color .5s;background-image:url(/assets/images/Icon_Minus.png);background-size:40%;background-color:var(--red);box-shadow:0 6px 10px 0 var(--redShadow)}.nf-topology-zoom-label{padding-right:10px}.nf-topology-zoom-button{height:50px;width:50px;margin-right:10px;border-radius:55px;border:unset;font-size:40px;font-family:icomoon!important;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;text-align:center;color:var(--primaryColor);line-height:49px;background-color:var(--navigation);cursor:pointer;overflow:hidden;z-index:24;box-shadow:0 20px 23px 0 var(--shadow);transition:background-color .5s}.nf-topology-zoom-button.plus:before{content:\"\\e937\"}.nf-topology-zoom-button.minus:before{content:\"\\e943\"}.nf-topology-zoom-button:hover{color:var(--white);background-color:var(--primaryColor);filter:brightness(90%);transition:background-color 1s;transition:.3s}.nf-topology-zoom-button:active{background-color:var(--icon);transform:scale(.97);transition:background-color 1s;transition:.3s}@supports ((-webkit-backdrop-filter: saturate(110%) blur(15px)) or (backdrop-filter: saturate(110%) blur(15px))){.nf-topology-zoom-button{background:var(--glass);-webkit-backdrop-filter:saturate(110%) blur(15px);backdrop-filter:saturate(110%) blur(15px)}}.placeholder{display:flex;align-items:center;justify-content:center;height:800px}.topotip{display:none;position:fixed;background:var(--navigation);border:0px;border-radius:12px;pointer-events:none;box-shadow:0 20px 23px 0 var(--shadow);transition:background-color .3s;padding:10px;font-size:17px;font-weight:700;color:var(--tableText);z-index:2000;opacity:1;max-width:400px}@supports ((-webkit-backdrop-filter: saturate(110%) blur(15px)) or (backdrop-filter: saturate(110%) blur(15px))){.topotip{background:var(--glass);-webkit-backdrop-filter:saturate(110%) blur(15px);backdrop-filter:saturate(110%) blur(15px)}}.nodes{cursor:pointer;box-shadow:0 30px 43px 0 var(--shadow)}.nf-links{cursor:pointer}.linkWidth{color:#fff}.nf-network-topology-container .loader{margin-left:-150px}.loader .bar1{background-color:var(--inputBorder)!important}.loader .bar2{background-color:var(--inputBorder)!important;animation-delay:-.7s}.loader .bar3{background-color:var(--inputBorder)!important;animation-delay:-.6s}.loader .bar4{background-color:var(--inputBorder)!important;animation-delay:-.5s}.loader .bar5{background-color:var(--inputBorder)!important;animation-delay:-.4s}.loader .bar6{background-color:var(--inputBorder)!important;animation-delay:-.3s}.changeView{display:flex;margin-top:32px;margin-left:10px;flex:1 0 auto}.changeView .changeViewLabel{margin-top:3px;margin-left:5px}.node circle{fill:#fff;stroke:#07397d;stroke-width:14px;box-shadow:0 20px 23px 0 var(--shadow)}.node text{font:27px sans-serif;cursor:pointer}.text-container{cursor:pointer}.link{fill:none;stroke:var(--table);stroke-width:5px;color:#fff}.nf-topology-legend{width:210px;border-radius:12px;margin-top:10px;margin-right:20px;position:fixed;top:0;right:0;background:var(--navigation);display:inline-block;box-shadow:0 20px 23px 0 var(--shadow);padding:5px 12px 7px}@supports ((-webkit-backdrop-filter: saturate(110%) blur(15px)) or (backdrop-filter: saturate(110%) blur(15px))){.nf-topology-legend{background:var(--glass);-webkit-backdrop-filter:saturate(110%) blur(15px);backdrop-filter:saturate(110%) blur(15px)}}.legend-item{width:100%;height:100%;display:inline-block}.legend-circle{height:12px;width:12px;border-radius:15px;display:inline-block;margin-top:7px}.legend-circle.servicepolicies{background-color:#ff0d49}.legend-circle.services{background-color:#08dc5a}.legend-circle.endpoints{background-color:#0273fb}.legend-circle.edgerouters{background-color:#ffc000}.legend-circle.erpolicies{background-color:#ff8400}.legend-circle.serviceerpolicies{background-color:#ff5900}.legend-text{display:inline-block;font-size:15px;font-weight:600;color:var(--tableText);padding-left:7px;padding-bottom:4px}.reset-button{height:50px;width:50px;border-radius:50px;margin-right:10px;background-size:contain;background-image:url(/assets/svgs/refresh.svg);cursor:pointer;overflow:hidden;z-index:24;box-shadow:0 20px 23px 0 var(--shadow);transition:.3s}.reset-button:hover{filter:brightness(90%);transform:scale(.97);transition:.3s}.reset-button:active{transform:scale(.9);transition:.3s}.sign_out_button{background-color:#2fa4e7;padding:16px 10px;color:#fff;float:left;text-decoration:none}.sign_out_button:hover{background-color:#1892d7}.sign_out_button a{color:#fff;text-decoration:none}.contextmenu_mouseout{fill:#f4f4f4;stroke:#fff;stroke-width:1px}.contextmenu_mouseover{fill:#c8c8c8}.menu2{position:fixed;background:#fff;color:#000;cursor:pointer;border:1px black solid}.contextmenu_text{position:fixed;background:var(--navigation);border:1px;border-radius:5px;pointer-events:none;box-shadow:0 20px 23px 0 var(--shadow);transition:background-color .3s;padding:5px;font-size:10px;font-weight:700;color:var(--tableText);z-index:2000;opacity:1;max-width:400px}.contextmenu{z-index:2000;opacity:1;position:fixed;background:#fff;color:#000;font-family:sans-serif;font-size:11px;box-shadow:2px 2px 2px #90908d;padding:2px;border-radius:12px;border:1px solid #c6c6c6;max-width:400px}.menuItems{display:block;color:#555;text-decoration:none;padding:6px 8px 6px 30px;position:relative}.context-menu{display:none;position:absolute;z-index:10}.context-menu__items{list-style:none;margin:0;padding:0}.context-menu__item{display:block;margin-bottom:4px}.container{margin:0 auto;padding:0 24px;max-width:960px}.context-menu__link{display:block;padding:4px 12px;color:#06a;text-decoration:none}.contextmenu_text:hover .divItemsHover{color:#fff;background-color:#06a}.context-menu--active{display:block}#topoDataTableHeader{float:left;min-width:250px;width:auto;height:360px;top:100px;border-bottom-left-radius:13px;border-bottom-right-radius:13px;display:none;background:#fff;border:2px solid gray!important;position:absolute!important}.table-filter-input{height:30px;width:100%;top:40px;border-radius:1px;border-color:#d3d3d3;background-color:#d3d3d3;box-shadow:0 20px 23px 0 var(--shadow);padding-top:3px;padding-left:2px;padding-right:2px}#topoDataTable{float:down;min-width:250px;width:auto;height:300px;top:55px;border-radius:10px;position:absolute!important;overflow:auto;background:#fff;font-family:sans-serif;font-size:16px;color:#06a;overflow-x:scroll}table{width:auto;height:auto;max-height:300px}tr{width:auto;padding:5px}th{width:auto;font-family:sans-serif;font-size:16px;color:#06a;font-weight:700;background-color:#06a}td{width:auto}th{width:auto;font-weight:700;padding:2px;border:1px solid #ccc;text-align:center}.context-menu{border-radius:12px;background:var(--navigation);width:200px;box-shadow:0 20px 23px 0 var(--shadow);position:relative;display:none}.context-menu .menu-options{list-style:none;padding:0}.context-menu .menu-options .menu-option{font-weight:700;font-size:16px;line-height:36px;color:var(--tableText);padding:1px 4px 1px 20px;cursor:pointer}.context-menu .menu-options .menu-option:hover{background:var(--primaryColor);color:var(--navigation)}@supports ((-webkit-backdrop-filter: saturate(110%) blur(15px)) or (backdrop-filter: saturate(110%) blur(15px))){.context-menu{background:var(--glass);-webkit-backdrop-filter:saturate(110%) blur(15px);backdrop-filter:saturate(110%) blur(15px)}}.spinner{position:absolute;right:1em;top:1em;display:inline-block;width:32px;height:32px;border-radius:50%;background:transparent;border-top:5px solid var(--placeholder);border-right:5px solid var(--placeholder);border-bottom:5px solid transparent;border-left:5px solid transparent;animation:loading .5s infinite linear}.disabled{-moz-user-select:-moz-none;-khtml-user-select:none;-webkit-user-select:none;-ms-user-select:none;pointer-events:none;cursor:pointer;opacity:.6}path:not(.loader path,.highcharts-root path){fill:none;stroke:var(--navigation);stroke-width:5px;color:#fff}@keyframes rotating{0%{transform:rotate(0)}to{transform:rotate(360deg)}}.rotating{animation:rotating 2s linear infinite}.mat-mdc-radio-button .mdc-radio .mdc-radio__native-control:disabled:checked+.mdc-radio__background .mdc-radio__outer-circle{background-color:var(--icon);border-width:4px}.mat-mdc-radio-button .mdc-radio .mdc-radio__native-control:disabled:checked+.mdc-radio__background .mdc-radio__inner-circle{border-color:var(--icon)}.mdc-radio__native-control:disabled:not(:checked)+.mdc-radio__background .mdc-radio__outer-circle{border-width:4px}#mat-radio-2>div>div>div.mdc-radio__background>div.mdc-radio__inner-circle .node.edge-router circle{stroke:#ffc000!important;stroke-width:12px}.node.endpoint circle{stroke:#0273fb!important;stroke-width:12px}.node.service circle{stroke:#08dc5a!important;stroke-width:12px}.node.service-policy circle{stroke:#ff0d49!important;stroke-width:12px}.node.edge-router-policy circle{stroke:#ff8400!important;stroke-width:12px}.node.service-edge-router-policy circle{stroke:#ff5900!important;stroke-width:12px}.text-container{color:var(--tableText);font-size:24px;font-weight:700;margin-left:20px;margin-top:8px;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}svg>g>g.node:first-of-type.terminate{cursor:pointer}svg>g>g.node:first-of-type.terminate .text-container{cursor:pointer}svg>g>g.node:first-of-type.terminate circle{cursor:pointer}svg>g>g.node:first-of-type.terminate:hover>rect{fill:url(#NodeHoverGradient)}.node>rect{fill:url(#NodeGradient)}.node.terminate{cursor:default;stroke-width:14px}.node.terminate .text-container{cursor:default}.node.terminate circle{cursor:default;stroke-width:14px}.node.terminate:hover>rect{fill:url(#NodeGradient)}.node:hover>rect{fill:url(#NodeHoverGradient)}p-chips.error .p-chips.p-component .p-chips-multiple-container{border-color:var(--red);border-width:2px}.checkboxes.error .mat-checkbox-frame{border-color:var(--red)}.checkboxes.error .mat-checkbox-label{color:var(--red)}.stop1{stop-color:var(--table);stop-opacity:.9}.stop2{stop-color:var(--table);stop-opacity:.65}.stop3{stop-color:var(--table);stop-opacity:0}.stop1a{stop-color:var(--background);stop-opacity:1}.stop2a{stop-color:var(--background);stop-opacity:.7}.stop3a{stop-color:var(--background);stop-opacity:0}\n"], dependencies: [{ kind: "directive", type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i6.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i6.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i6.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i6.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { kind: "directive", type: i6.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i6.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i7.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple", "hideSingleSelectionIndicator"], exportAs: ["matAutocomplete"] }, { kind: "component", type: i8.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { kind: "directive", type: i7.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { kind: "component", type: i9.LoadingIndicatorComponent, selector: "lib-loading-indicator", inputs: ["isLoading"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+export { NetworkVisualizerComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NetworkVisualizerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-network-visualizer', encapsulation: ViewEncapsulation.None, template: "<div class=\"ziti-page-container ziti-identities-container\">\n\n    <div class=\"nf-network-topology-container\" >\n\n      <div class=\"css-header\">{{title}} </div><br>\n\n      <div  class=\"nf-net-vis-controls-header\">\n        <div class=\"nf-topology-zoom-container\">\n          <!--button (click)=\"zoomOut()\" class=\"nf-topology-zoom-button minus\"></button>\n          <button (click)=\"zoomIn()\" class=\"nf-topology-zoom-button plus\"></button-->\n          <div (click)=\"resetTree('Yes')\" class=\"reset-button\" title=\"Reset\"></div>\n        </div>\n        <select\n            (change)=\"resourceTypeChanged()\"\n            [(ngModel)]=\"resourceType\"\n            [ngClass]=\"{ 'resource-type-error': resourceTypeError }\"\n            class=\"resource-type-select\"\n            id=\"ResourceTypeSelect\"\n        >\n          <option value=\"\">Select Resource Type</option>\n          <option value=\"service-policies\">Service Policies</option>\n          <option value=\"services\">Services</option>\n          <option value=\"identities\">Identities</option>\n          <option value=\"edge-routers\">Edge Routers</option>\n          <option value=\"edge-router-policies\">Edge Router Policies</option>\n          <option value=\"service-edge-router-policies\">Service Edge Router Policies</option>\n        </select>\n        <div class=\"nf-net-vis-filter-container listBox row\">\n          <input\n              (keyup)=\"filterSearchArray()\"\n              [(ngModel)]=\"filterText\"\n              [matAutocomplete]=\"auto\"\n              class=\"nf-topology-filter-input\"\n              id=\"filterText\"\n              matInput\n              placeholder=\"Type to Filter\"\n          />\n\n          <div\n              (click)=\"clearSearchFilter()\"\n              *ngIf=\"filterText !== ''\"\n              class=\"buttonBall close\"\n              id=\"ClearSearchFilter\"\n          ></div>\n          <div [hidden]=\"!noSearchResults\" class=\"no-results-warning\">No Results Found</div>\n          <mat-autocomplete #auto=\"matAutocomplete\" (optionSelected)=\"autocompleteSearch($event)\">\n            <mat-option *ngFor=\"let option of autocompleteOptions\" [value]=\"option\">\n              {{ option }}\n            </mat-option>\n          </mat-autocomplete>\n        </div>\n      </div>\n\n      <div class=\"nf-topology-legend\">\n        <div class=\"legend-item\">\n          <div class=\"legend-circle servicepolicies\"></div>\n          <div class=\"legend-text\">Service Policies</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle services\"></div>\n          <div class=\"legend-text\">Services</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle endpoints\"></div>\n          <div class=\"legend-text\">Identities</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle edgerouters\"></div>\n          <div class=\"legend-text\">Edge Routers</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle erpolicies\"></div>\n          <div class=\"legend-text\">Edge Router Policies</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle serviceerpolicies\"></div>\n          <div class=\"legend-text\">Service Router Policies</div>\n        </div>\n      </div>\n\n      <div class=\"topotip\" id=\"tooltip\"></div>\n      <svg style='pointer-events:all' id=\"NetworkVisualizerSVG\"></svg>\n      <lib-loading-indicator *ngIf=\"isLoading\" [isLoading]=\"isLoading\"></lib-loading-indicator>\n    </div>\n\n</div>\n", styles: [".ziti-page-container{height:100%;width:100%;left:0;display:flex;flex-direction:column;position:absolute;padding-top:1px;padding-left:3px;padding-right:3px;top:0}.nf-network-topology-container{overflow:hidden;width:100%;height:100%;background-color:var(--background);z-index:1001;margin:auto;inset:0;padding-top:1px;padding-left:3px;padding-right:3px;background:#f5e9f2;background-image:linear-gradient(#ecd3e6 2px,transparent 0),linear-gradient(90deg,#ecd3e6 2px,transparent 0),linear-gradient(#ecd3e6 1px,transparent 0),linear-gradient(90deg,#ecd3e6 1px,transparent 0);background-size:40px 40px,40px 40px,10px 10px,10px 10px}.css-header{height:50px;font-size:25px;font-weight:600;margin:8px 0 0 2px;font-family:Russo One;color:#0027ab;font-size:30px;text-transform:uppercase;font-weight:400;background-color:transparent}.resource-type-select{width:230px;flex-shrink:0;border-radius:27px;height:51px;margin-top:20px;margin-left:20px;-webkit-backdrop-filter:saturate(110%) blur(15px);backdrop-filter:saturate(110%) blur(15px);background-color:#ffffff80!important;border-color:var(--navigation);box-shadow:0 20px 23px 0 var(--shadow);color:var(--tableText);padding-left:20px}select{background-image:url(/assets/svgs/ArrowDown.svg);background-position:center right 18px;background-repeat:no-repeat;background-size:18px;padding-right:38px}.no-results-warning{bottom:-20px;left:20px;font-size:15px;color:var(--tableText);padding-left:20px;padding-top:5px}.resource-type-error{border-width:3px;border-color:var(--red)!important}.nf-links{stroke:#fff;stroke-opacity:1.6}.nf-net-vis-controls-header{display:flex;flex-direction:row;position:absolute;z-index:99999;flex:1 0 auto;top:50px}.nf-net-vis-filter-container{max-width:300px;margin-top:20px;margin-left:10px;flex:1 0 auto}.table-filter-container{max-width:300px;margin-top:0;margin-left:1px;flex:1 0 auto}#ClearSearchFilter{position:absolute;right:2px;top:2px;width:20px;height:20px;font-size:25px;color:var(--tableText);z-index:99999999}#popupTableTitle{width:100%;font-weight:900;display:inline-block;background-color:var(--navigation);box-shadow:0 20px 23px 0 var(--shadow);border:2px #d3d3d3!important;text-align:center;border:2px;border-color:#d3d3d3;height:25px;top:2px;color:#fff;padding-right:5px;background:#000;cursor:move}#tra:hover{text-decoration:underline}#CloseDataTable{position:absolute;right:5px;top:-33px;width:25px;height:25px;font-size:15px;color:#fff;z-index:99999999}.copydatatable{width:135px;height:17px;font-size:10pt;font-family:tahoma;top:95%;right:0%;border-radius:5px;background:#fff;border:0px solid gray!important;position:absolute!important;text-transform:uppercase;cursor:pointer;z-index:999}.copydatatable:hover{text-decoration:underline}.nf-topology-filter-input{height:50px;border-radius:25px;border-color:var(--navigation);background-color:var(--navigation);box-shadow:0 20px 23px 0 var(--shadow);padding-left:20px;padding-right:35px}.nf-topology-select-container{max-width:400px;margin-top:20px;margin-left:20px;flex:1 0 auto}.nf-topology-select-input{height:45px;border-radius:25px;border-color:var(--navigation);background-color:var(--navigation);box-shadow:0 20px 23px 0 var(--shadow);padding-left:20px}input:focus,textarea:focus,select:focus{box-shadow:0 20px 23px 0 var(--shadow)}@supports ((-webkit-backdrop-filter: saturate(110%) blur(15px)) or (backdrop-filter: saturate(110%) blur(15px))){.nf-topology-filter-input{background:var(--glass)!important;-webkit-backdrop-filter:saturate(110%) blur(15px);backdrop-filter:saturate(110%) blur(15px)}}.nf-topology-zoom-container{display:flex;margin-left:20px;margin-top:20px;flex:1 0 auto}.nf-topology-zoom-button.minus{height:50px;width:50px;margin-right:10px;border-radius:55px;border:unset;font-size:40px;font-family:icomoon!important;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;text-align:center;color:var(--primaryColor);line-height:49px;background-color:var(--navigation);cursor:pointer;overflow:hidden;z-index:24;box-shadow:0 20px 23px 0 var(--shadow);transition:background-color .5s;background-image:url(/assets/images/Icon_Minus.png);background-size:40%;background-color:var(--red);box-shadow:0 6px 10px 0 var(--redShadow)}.nf-topology-zoom-label{padding-right:10px}.nf-topology-zoom-button{height:50px;width:50px;margin-right:10px;border-radius:55px;border:unset;font-size:40px;font-family:icomoon!important;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;text-align:center;color:var(--primaryColor);line-height:49px;background-color:var(--navigation);cursor:pointer;overflow:hidden;z-index:24;box-shadow:0 20px 23px 0 var(--shadow);transition:background-color .5s}.nf-topology-zoom-button.plus:before{content:\"\\e937\"}.nf-topology-zoom-button.minus:before{content:\"\\e943\"}.nf-topology-zoom-button:hover{color:var(--white);background-color:var(--primaryColor);filter:brightness(90%);transition:background-color 1s;transition:.3s}.nf-topology-zoom-button:active{background-color:var(--icon);transform:scale(.97);transition:background-color 1s;transition:.3s}@supports ((-webkit-backdrop-filter: saturate(110%) blur(15px)) or (backdrop-filter: saturate(110%) blur(15px))){.nf-topology-zoom-button{background:var(--glass);-webkit-backdrop-filter:saturate(110%) blur(15px);backdrop-filter:saturate(110%) blur(15px)}}.placeholder{display:flex;align-items:center;justify-content:center;height:800px}.topotip{display:none;position:fixed;background:var(--navigation);border:0px;border-radius:12px;pointer-events:none;box-shadow:0 20px 23px 0 var(--shadow);transition:background-color .3s;padding:10px;font-size:17px;font-weight:700;color:var(--tableText);z-index:2000;opacity:1;max-width:400px}@supports ((-webkit-backdrop-filter: saturate(110%) blur(15px)) or (backdrop-filter: saturate(110%) blur(15px))){.topotip{background:var(--glass);-webkit-backdrop-filter:saturate(110%) blur(15px);backdrop-filter:saturate(110%) blur(15px)}}.nodes{cursor:pointer;box-shadow:0 30px 43px 0 var(--shadow)}.nf-links{cursor:pointer}.linkWidth{color:#fff}.nf-network-topology-container .loader{margin-left:-150px}.loader .bar1{background-color:var(--inputBorder)!important}.loader .bar2{background-color:var(--inputBorder)!important;animation-delay:-.7s}.loader .bar3{background-color:var(--inputBorder)!important;animation-delay:-.6s}.loader .bar4{background-color:var(--inputBorder)!important;animation-delay:-.5s}.loader .bar5{background-color:var(--inputBorder)!important;animation-delay:-.4s}.loader .bar6{background-color:var(--inputBorder)!important;animation-delay:-.3s}.changeView{display:flex;margin-top:32px;margin-left:10px;flex:1 0 auto}.changeView .changeViewLabel{margin-top:3px;margin-left:5px}.node circle{fill:#fff;stroke:#07397d;stroke-width:14px;box-shadow:0 20px 23px 0 var(--shadow)}.node text{font:27px sans-serif;cursor:pointer}.text-container{cursor:pointer}.link{fill:none;stroke:var(--table);stroke-width:5px;color:#fff}.nf-topology-legend{width:210px;border-radius:12px;margin-top:10px;margin-right:20px;position:fixed;top:0;right:0;background:var(--navigation);display:inline-block;box-shadow:0 20px 23px 0 var(--shadow);padding:5px 12px 7px}@supports ((-webkit-backdrop-filter: saturate(110%) blur(15px)) or (backdrop-filter: saturate(110%) blur(15px))){.nf-topology-legend{background:var(--glass);-webkit-backdrop-filter:saturate(110%) blur(15px);backdrop-filter:saturate(110%) blur(15px)}}.legend-item{width:100%;height:100%;display:inline-block}.legend-circle{height:12px;width:12px;border-radius:15px;display:inline-block;margin-top:7px}.legend-circle.servicepolicies{background-color:#ff0d49}.legend-circle.services{background-color:#08dc5a}.legend-circle.endpoints{background-color:#0273fb}.legend-circle.edgerouters{background-color:#ffc000}.legend-circle.erpolicies{background-color:#ff8400}.legend-circle.serviceerpolicies{background-color:#ff5900}.legend-text{display:inline-block;font-size:15px;font-weight:600;color:var(--tableText);padding-left:7px;padding-bottom:4px}.reset-button{height:50px;width:50px;border-radius:50px;margin-right:10px;background-size:contain;background-image:url(/assets/svgs/refresh.svg);cursor:pointer;overflow:hidden;z-index:24;box-shadow:0 20px 23px 0 var(--shadow);transition:.3s}.reset-button:hover{filter:brightness(90%);transform:scale(.97);transition:.3s}.reset-button:active{transform:scale(.9);transition:.3s}.sign_out_button{background-color:#2fa4e7;padding:16px 10px;color:#fff;float:left;text-decoration:none}.sign_out_button:hover{background-color:#1892d7}.sign_out_button a{color:#fff;text-decoration:none}.contextmenu_mouseout{fill:#f4f4f4;stroke:#fff;stroke-width:1px}.contextmenu_mouseover{fill:#c8c8c8}.menu2{position:fixed;background:#fff;color:#000;cursor:pointer;border:1px black solid}.contextmenu_text{position:fixed;background:var(--navigation);border:1px;border-radius:5px;pointer-events:none;box-shadow:0 20px 23px 0 var(--shadow);transition:background-color .3s;padding:5px;font-size:10px;font-weight:700;color:var(--tableText);z-index:2000;opacity:1;max-width:400px}.contextmenu{z-index:2000;opacity:1;position:fixed;background:#fff;color:#000;font-family:sans-serif;font-size:11px;box-shadow:2px 2px 2px #90908d;padding:2px;border-radius:12px;border:1px solid #c6c6c6;max-width:400px}.menuItems{display:block;color:#555;text-decoration:none;padding:6px 8px 6px 30px;position:relative}.context-menu{display:none;position:absolute;z-index:10}.context-menu__items{list-style:none;margin:0;padding:0}.context-menu__item{display:block;margin-bottom:4px}.container{margin:0 auto;padding:0 24px;max-width:960px}.context-menu__link{display:block;padding:4px 12px;color:#06a;text-decoration:none}.contextmenu_text:hover .divItemsHover{color:#fff;background-color:#06a}.context-menu--active{display:block}#topoDataTableHeader{float:left;min-width:250px;width:auto;height:360px;top:100px;border-bottom-left-radius:13px;border-bottom-right-radius:13px;display:none;background:#fff;border:2px solid gray!important;position:absolute!important}.table-filter-input{height:30px;width:100%;top:40px;border-radius:1px;border-color:#d3d3d3;background-color:#d3d3d3;box-shadow:0 20px 23px 0 var(--shadow);padding-top:3px;padding-left:2px;padding-right:2px}#topoDataTable{float:down;min-width:250px;width:auto;height:300px;top:55px;border-radius:10px;position:absolute!important;overflow:auto;background:#fff;font-family:sans-serif;font-size:16px;color:#06a;overflow-x:scroll}table{width:auto;height:auto;max-height:300px}tr{width:auto;padding:5px}th{width:auto;font-family:sans-serif;font-size:16px;color:#06a;font-weight:700;background-color:#06a}td{width:auto}th{width:auto;font-weight:700;padding:2px;border:1px solid #ccc;text-align:center}.context-menu{border-radius:12px;background:var(--navigation);width:200px;box-shadow:0 20px 23px 0 var(--shadow);position:relative;display:none}.context-menu .menu-options{list-style:none;padding:0}.context-menu .menu-options .menu-option{font-weight:700;font-size:16px;line-height:36px;color:var(--tableText);padding:1px 4px 1px 20px;cursor:pointer}.context-menu .menu-options .menu-option:hover{background:var(--primaryColor);color:var(--navigation)}@supports ((-webkit-backdrop-filter: saturate(110%) blur(15px)) or (backdrop-filter: saturate(110%) blur(15px))){.context-menu{background:var(--glass);-webkit-backdrop-filter:saturate(110%) blur(15px);backdrop-filter:saturate(110%) blur(15px)}}.spinner{position:absolute;right:1em;top:1em;display:inline-block;width:32px;height:32px;border-radius:50%;background:transparent;border-top:5px solid var(--placeholder);border-right:5px solid var(--placeholder);border-bottom:5px solid transparent;border-left:5px solid transparent;animation:loading .5s infinite linear}.disabled{-moz-user-select:-moz-none;-khtml-user-select:none;-webkit-user-select:none;-ms-user-select:none;pointer-events:none;cursor:pointer;opacity:.6}path:not(.loader path,.highcharts-root path){fill:none;stroke:var(--navigation);stroke-width:5px;color:#fff}@keyframes rotating{0%{transform:rotate(0)}to{transform:rotate(360deg)}}.rotating{animation:rotating 2s linear infinite}.mat-mdc-radio-button .mdc-radio .mdc-radio__native-control:disabled:checked+.mdc-radio__background .mdc-radio__outer-circle{background-color:var(--icon);border-width:4px}.mat-mdc-radio-button .mdc-radio .mdc-radio__native-control:disabled:checked+.mdc-radio__background .mdc-radio__inner-circle{border-color:var(--icon)}.mdc-radio__native-control:disabled:not(:checked)+.mdc-radio__background .mdc-radio__outer-circle{border-width:4px}#mat-radio-2>div>div>div.mdc-radio__background>div.mdc-radio__inner-circle .node.edge-router circle{stroke:#ffc000!important;stroke-width:12px}.node.endpoint circle{stroke:#0273fb!important;stroke-width:12px}.node.service circle{stroke:#08dc5a!important;stroke-width:12px}.node.service-policy circle{stroke:#ff0d49!important;stroke-width:12px}.node.edge-router-policy circle{stroke:#ff8400!important;stroke-width:12px}.node.service-edge-router-policy circle{stroke:#ff5900!important;stroke-width:12px}.text-container{color:var(--tableText);font-size:24px;font-weight:700;margin-left:20px;margin-top:8px;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}svg>g>g.node:first-of-type.terminate{cursor:pointer}svg>g>g.node:first-of-type.terminate .text-container{cursor:pointer}svg>g>g.node:first-of-type.terminate circle{cursor:pointer}svg>g>g.node:first-of-type.terminate:hover>rect{fill:url(#NodeHoverGradient)}.node>rect{fill:url(#NodeGradient)}.node.terminate{cursor:default;stroke-width:14px}.node.terminate .text-container{cursor:default}.node.terminate circle{cursor:default;stroke-width:14px}.node.terminate:hover>rect{fill:url(#NodeGradient)}.node:hover>rect{fill:url(#NodeHoverGradient)}p-chips.error .p-chips.p-component .p-chips-multiple-container{border-color:var(--red);border-width:2px}.checkboxes.error .mat-checkbox-frame{border-color:var(--red)}.checkboxes.error .mat-checkbox-label{color:var(--red)}.stop1{stop-color:var(--table);stop-opacity:.9}.stop2{stop-color:var(--table);stop-opacity:.65}.stop3{stop-color:var(--table);stop-opacity:0}.stop1a{stop-color:var(--background);stop-opacity:1}.stop2a{stop-color:var(--background);stop-opacity:.7}.stop3a{stop-color:var(--background);stop-opacity:0}\n"] }]
+        }], ctorParameters: function () { return [{ type: i10.SettingsService, decorators: [{
+                    type: Inject,
+                    args: [SETTINGS_SERVICE]
+                }] }, { type: i11.ZitiDataService, decorators: [{
+                    type: Inject,
+                    args: [ZITI_DATA_SERVICE]
+                }] }, { type: i1.HttpClient }, { type: i2.LoggerService }, { type: i3.TreeNodeProcessor }, { type: i4.NetworkVisualizerHelper }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-visualizer.component.js","sourceRoot":"","sources":["../../../../../../../projects/ziti-console-lib/src/lib/features/visualizer/network-visualizer/network-visualizer.component.ts","../../../../../../../projects/ziti-console-lib/src/lib/features/visualizer/network-visualizer/network-visualizer.component.html"],"names":[],"mappings":"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","sourcesContent":["/* eslint prefer-const: 1 */\nimport {\n  Component,\n  ViewChild,\n  Inject,\n  OnInit,\n  ViewEncapsulation,\n  Injectable,\n} from '@angular/core';\nimport { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog';\nimport { Router } from '@angular/router';\nimport {\n  SETTINGS_SERVICE,\n  SettingsService,\n} from '../../../services/settings.service';\nimport {\n  ZITI_DATA_SERVICE,\n  ZitiDataService,\n} from '../../../services/ziti-data.service';\nimport {catchError} from \"rxjs/operators\";\nimport {firstValueFrom, map, Observable} from \"rxjs\";\nimport { VisualizerServiceClass  } from '../visualizer-service.class';\nimport * as d3 from 'd3';\nimport $ from 'jquery';\nimport _ from 'lodash';\nimport { Subscription } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\nimport { take, tap } from 'rxjs/operators';\nimport { MatIconModule } from '@angular/material/icon';\nimport { HttpClient} from '@angular/common/http';\nimport { TreeNodeProcessor } from './network-visualizer.treenodeprocessor';\nimport { NetworkVisualizerHelper } from './network-visualizer.helper';\nimport {LoggerService} from \"../../messaging/logger.service\";\n\n@Component({\n  selector: 'app-network-visualizer',\n  encapsulation: ViewEncapsulation.None,\n  templateUrl: './network-visualizer.component.html',\n  styleUrls: ['./network-visualizer.component.scss'],\n})\n\nexport class NetworkVisualizerComponent extends VisualizerServiceClass implements OnInit {\n// export class NetworkVisualizerComponent  implements OnInit {\n  title = 'Network Visualizer'\n  public d3;\n  uniqId = 0;\n  treetooltip;\n  fullScreen = false;\n  isLoading = true;\n  noSearchResults = false;\n  services;\n  identities;\n  edgerouters;\n  service_policies;\n  router_policies;\n  service_router_policies;\n  configs;\n  baseNetworkGraph;\n  networkGraph;\n  currentNetwork;\n  searchRootNode;\n\n  servicePoliciesTreeNodes = [];\n  servicesTreeNodes = [];\n  identitiesTreeNodes = [];\n  edgeroutersTreeNodes = [];\n  erPoliciesTreeNodes = [];\n  serviceEdgeRouterPolicyTreeNodes = [];\n\n  autocompleteOptions;\n  resourceTypeError = false;\n  filterText = '';\n  resourceType = '';\n  zoom;\n  svg;\n  treemap;\n  nodes;\n  node;\n  link;\n  links;\n  linkExit;\n  linkUpdate;\n  openNodes = [];\n  transform;\n  nodeUpdate;\n  nodeExit;\n  nodeEnter;\n  contextmenuNode;\n  circles;\n  contextmenuNodeType:any = [];\n  simulation;\n  treeData;\n  graphtooltip;\n\n  constructor(\n     @Inject(SETTINGS_SERVICE) public settingsService: SettingsService,\n     @Inject(ZITI_DATA_SERVICE) private zitiService: ZitiDataService,\n     private httpClient: HttpClient,\n     private logger: LoggerService,\n     public treeNodeProcessor: TreeNodeProcessor,\n     public topologyHelper: NetworkVisualizerHelper,\n  ) {\n     super();\n    // super(settingsService, zitiService);\n  }\n\n  override ngOnInit(): void {\n     this.getNetworkObjects();\n  }\n\n    getPagingObject(pagesize) {\n      const paging = {\n        searchOn: 'name',\n        noSearch: false,\n        filter: '',\n        total: pagesize,\n        page: 1,\n        sort: 'name',\n        order: 'asc',\n      };\n      return  paging;\n    }\n\n  async getNetworkObjects() {\n    this.isLoading = true;\n     await this.readAllObjects();\n     this.processFirstNetworkGraph();\n  }\n\n   async fetchIdentities (pagesize) {\n      const identities_paging = this.getPagingObject(pagesize);\n      return await this.zitiService\n      .get(`identities`, identities_paging, [])\n      .then(async (result) => {\n         this.identities = result.data;\n         if (!this.identities || this.identities.length === 0) {\n            this.identities = [];\n            this.isLoading = false;\n         } else {\n           const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);\n           const promises = [];\n           for (let page = 2; page <= pages; page++) {\n             identities_paging.page = page;\n             const tmp_promise = await this.zitiService\n              .get(\n                `identities`,\n                 identities_paging,\n                []\n              ).then((pageResult) => {\n                pageResult.data.forEach((serv) => {\n                  this.identities.push(serv);\n                });\n              });\n             promises.push(tmp_promise);\n           }\n           Promise.all(promises).then(() => {});\n        }\n    }).catch(error => {\n        this.logger.error('Error in fetching Identities', error.message);\n     });  // identity promises\n  }\n\n  async fetchServices(pagesize) {\n   const services_paging = this.getPagingObject(pagesize);\n    return await this.zitiService\n          .get(`services`, services_paging, [])\n          .then( async (result) => {\n            this.services = result.data;\n\n            if (!this.services || this.services.length === 0) {\n              this.services = [];\n              this.isLoading = false;\n            } else {\n              const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);\n              const s_promises = [];\n              for (let page = 2; page <= pages; page++) {\n                services_paging.page = page;\n                const tmp_promise = await this.zitiService\n                  .get(\n                    `services`,\n                     services_paging,\n                    []\n                  )\n                  .then((pageResult) => {\n                    pageResult.data.forEach((serv) => {\n                      this.services.push(serv);\n                    });\n                  });\n                s_promises.push(tmp_promise);\n              }\n              Promise.all(s_promises).then(() => { });\n            }\n        }).catch(error => {\n           this.logger.error('Error in fetching services', error.message);\n        });\n  }\n\n  async fetchServicePolicies(pagesize) {\n       const servicesPolicies_paging = this.getPagingObject(pagesize);\n      return await this.zitiService\n          .get(`service-policies`, servicesPolicies_paging, [])\n          .then( async (result) => {\n            this.service_policies = result.data;\n\n            if (!this.service_policies || this.service_policies.length === 0) {\n              this.service_policies = [];\n              this.isLoading = false;\n            } else {\n              const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);\n              const sp_promises = [];\n              for (let page = 2; page <= pages; page++) {\n                servicesPolicies_paging.page = page;\n                const tmp_promise = await this.zitiService\n                  .get(\n                    `service-policies`,\n                     servicesPolicies_paging,\n                    []\n                  )\n                  .then((pageResult) => {\n                    pageResult.data.forEach((serv) => {\n                      this.service_policies.push(serv);\n                    });\n                  });\n                sp_promises.push(tmp_promise);\n              }\n\n              Promise.all(sp_promises).then(() => { });\n            }\n       }).catch(error => {\n          this.logger.error('Error in fetching service-policies', error.message);\n        });\n  }\n\n  async fetchEdgeRouters(pagesize) {\n       const routers_paging = this.getPagingObject(pagesize);\n       return await this.zitiService\n          .get(`edge-routers`, routers_paging, [])\n          .then( async (result) => {\n            this.edgerouters = result.data;\n            if (!this.edgerouters || this.edgerouters.length === 0) {\n              this.edgerouters = [];\n              this.isLoading = false;\n            } else {\n              const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);\n              const r_promises = [];\n              for (let page = 2; page <= pages; page++) {\n                routers_paging.page = page;\n                const tmp_promise = await this.zitiService\n                  .get(\n                    `edge-routers`,\n                     routers_paging,\n                    []\n                  )\n                  .then((pageResult) => {\n                    pageResult.data.forEach((serv) => {\n                      this.edgerouters.push(serv);\n                    });\n                  });\n                r_promises.push(tmp_promise);\n              }\n              Promise.all(r_promises).then(() => { });\n            }\n       }).catch(error => {\n         this.logger.error('Error in fetching edge-routers', error.message);\n       });\n  }\n\n async findEdgeRouterPolicies(pagesize) {\n      this.router_policies = [];\n      const erpolicies_paging = this.getPagingObject(pagesize);\n      return await this.zitiService\n          .get(`edge-router-policies`, erpolicies_paging, [])\n          .then(async (result) => {\n            this.router_policies = result.data;\n            if (!this.router_policies || this.router_policies.length === 0) {\n              this.isLoading = false;\n            } else {\n              const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);\n              const r_promises = [];\n              for (let page = 2; page <= pages; page++) {\n                erpolicies_paging.page = page;\n                const tmp_promise = await this.zitiService\n                  .get(\n                    `edge-router-policies`,\n                     erpolicies_paging,\n                    []\n                  )\n                  .then((pageResult) => {\n                    pageResult.data.forEach((serv) => {\n                      this.router_policies.push(serv);\n                    });\n                  });\n                r_promises.push(tmp_promise);\n              }\n\n              Promise.all(r_promises).then(() => { });\n            }\n       }).catch(error => {\n           this.logger.error('Error in fetching edge-router-policies', error);\n       });\n }\n async fetchServiceEdgeRouterPolicies(pagesize) {\n     this.service_router_policies = [];\n     const serp_paging = this.getPagingObject(pagesize);\n     return await this.zitiService\n          .get(`service-edge-router-policies`, serp_paging, [])\n          .then(async (result) => {\n            this.service_router_policies = result.data;\n\n            if (!this.service_router_policies || this.service_router_policies.length === 0) {\n              this.isLoading = false;\n            } else {\n              const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);\n              const r_promises = [];\n              for (let page = 2; page <= pages; page++) {\n                serp_paging.page = page;\n                const tmp_promise = await this.zitiService\n                  .get(\n                    `service-edge-router-policies`,\n                     serp_paging,\n                    []\n                  )\n                  .then((pageResult) => {\n                    pageResult.data.forEach((serv) => {\n                      this.service_router_policies.push(serv);\n                    });\n                  });\n                r_promises.push(tmp_promise);\n              }\n              Promise.all(r_promises).then(() => { });\n            }\n       }).catch(error => {\n           this.logger.error('Error in fetching service-edge-router-policies', error);\n       });\n }\n async fetchConfigs(pagesize) {\n    this.configs = [];\n    const configs_paging = this.getPagingObject(pagesize);\n    return await this.zitiService\n          .get(`configs`, configs_paging, [])\n          .then(async (result) => {\n            this.configs = result.data;\n\n            if (!this.configs || this.configs.length === 0) {\n              this.configs = [];\n            } else {\n              const pages = Math.ceil(result.meta.pagination.totalCount / pagesize);\n              const r_promises = [];\n              for (let page = 2; page <= pages; page++) {\n                configs_paging.page = page;\n                const tmp_promise = await this.zitiService\n                  .get(\n                    `configs`,\n                     configs_paging,\n                    []\n                  )\n                  .then((pageResult) => {\n                    pageResult.data.forEach((serv) => {\n                      this.configs.push(serv);\n                    });\n                  });\n                r_promises.push(tmp_promise);\n              }\n              Promise.all(r_promises).then(() => { });\n            }\n         }).catch(error => {\n          this.logger.error('Error in fetching configs', error);\n          });\n\n }\n\n async readAllObjects() {\n   const myPromise =  await new Promise(  (resolve, reject) => {\n     let networkVisPromises =[];\n     const pagesize = 500;\n     const eps = this.fetchIdentities(pagesize);\n     const ss = this.fetchServices(pagesize);\n     const sps = this.fetchServicePolicies(pagesize);\n     const ers = this.fetchEdgeRouters(pagesize);\n     const erps = this.findEdgeRouterPolicies(pagesize);\n     const serps = this.fetchServiceEdgeRouterPolicies(pagesize);\n     const cfg = this.fetchConfigs(pagesize);\n     Promise.all([eps, ss, sps, ers, erps, erps, serps, cfg]).then(() => {\n      resolve('end');\n     });\n   });\n\n }\n\n  processFirstNetworkGraph() {\n        try {\n            const treeObj = this.topologyHelper.getResourceTreeObj(\n                'this.currentNetwork.name',\n                'this.currentNetwork.status',\n                this.services,\n                this.identities,\n                this.service_policies,\n                this.edgerouters,\n                this.router_policies,\n                this.service_router_policies,\n                this.uniqId,\n                this.logger\n            );\n\n            this.uniqId = treeObj.lastId;\n            this.networkGraph = d3.hierarchy(treeObj, function (d) {\n                return d.children;\n            });\n            this.baseNetworkGraph = this.networkGraph;\n            this.servicePoliciesTreeNodes = [];\n            this.servicesTreeNodes = [];\n            this.identitiesTreeNodes = [];\n            this.edgeroutersTreeNodes = [];\n            this.erPoliciesTreeNodes = [];\n            this.serviceEdgeRouterPolicyTreeNodes = [];\n\n            this.servicePoliciesTreeNodes = this.fillAutoCompleteTreeNodes(\n                this.networkGraph.children[0],\n                this.servicePoliciesTreeNodes,\n                'ServicePolicy'\n            );\n            this.servicesTreeNodes = this.fillAutoCompleteTreeNodes(\n                this.networkGraph.children[1],\n                this.servicesTreeNodes,\n                'Service'\n            );\n            this.identitiesTreeNodes = this.fillAutoCompleteTreeNodes(\n                this.networkGraph.children[2],\n                this.identitiesTreeNodes,\n                'Identity'\n            );\n            this.edgeroutersTreeNodes = this.fillAutoCompleteTreeNodes(\n                this.networkGraph.children[3],\n                this.edgeroutersTreeNodes,\n                'Edge Router'\n            );\n            this.erPoliciesTreeNodes = this.fillAutoCompleteTreeNodes(\n                this.networkGraph.children[4],\n                this.erPoliciesTreeNodes,\n                'Router Policy'\n            );\n\n            this.serviceEdgeRouterPolicyTreeNodes = this.fillAutoCompleteTreeNodes(\n                this.networkGraph.children[5],\n                this.serviceEdgeRouterPolicyTreeNodes,\n                'Service Router Policy'\n            );\n\n            this.initTopoView();\n        } catch (err:any) {\n            this.logger.error(err.message);\n        }\n\n        this.isLoading = false;\n  }\n    fillAutoCompleteTreeNodes(nodeObj, arr, typeName) {\n        const name = nodeObj.data.name;\n        // const id = nodeObj.data.id;\n        if (!name) {\n            return;\n        }\n        if (typeof nodeObj.data.type === 'undefined') {\n            //      //\n        } else {\n            if (arr.indexOf(name) < 0 && nodeObj.data.type === typeName) {\n                arr.push(name);\n            }\n        }\n\n        const childNodes = nodeObj.children ? nodeObj.children : nodeObj._children;\n        for (let i = 0; childNodes && i < childNodes.length; i++) {\n            this.fillAutoCompleteTreeNodes(childNodes[i], arr, typeName);\n        }\n\n        return arr;\n    }\n\n    autocompleteSearch(event) {\n        const str = event ? event.option.value : '';\n        this.searchResourceConditionCheck(str);\n    }\n\n    resourceTypeChanged() {\n        this.resetSearchNode();\n        this.clearSearchLinkColors();\n        if (_.isEmpty(this.resourceType)) {\n            this.autocompleteOptions = [];\n            this.clearSearchFilter();\n            this.resourceTypeError = !_.isEmpty(this.filterText);\n            return;\n        }\n        this.filterText = '';\n        this.resourceTypeError = false;\n\n        if (this.resourceType === 'service-policies') {\n            this.autocompleteOptions = this.servicePoliciesTreeNodes;\n        } else if (this.resourceType === 'services') {\n            this.autocompleteOptions = this.servicesTreeNodes;\n        } else if (this.resourceType === 'identities') {\n            this.autocompleteOptions = this.identitiesTreeNodes;\n        } else if (this.resourceType === 'edge-routers') {\n            this.autocompleteOptions = this.edgeroutersTreeNodes;\n        } else if (this.resourceType === 'edge-router-policies') {\n            this.autocompleteOptions = this.erPoliciesTreeNodes;\n        } else if (this.resourceType === 'service-edge-router-policies') {\n            this.autocompleteOptions = this.serviceEdgeRouterPolicyTreeNodes;\n        }\n\n        if (!_.isEmpty(this.filterText)) {\n            this.searchResourceConditionCheck(this.filterText);\n        }\n    }\n    searchResourceConditionCheck(searchTxt) {\n      if (this.resourceType === '' && searchTxt !== '') {\n          // if (searchTxt !== '') {\n               this.resourceTypeError = true;\n              return;\n      } else {\n           this.searchResourceInTree(searchTxt);\n      }\n\n    }\n    searchResourceInTree(searchTxt) {\n      //  this.closeTable();\n        this.noSearchResults = false;\n\n        this.resourceTypeError = false;\n        this.resetTree(null);\n        if (searchTxt === '') {\n            this.clearSearchLinkColors();\n        } else {\n            this.resetSearchNode();\n            this.clearSearchLinkColors();\n            let paths = [];\n            let targetNodes = [];\n            const nodeIds = [];\n            if (this.resourceType === 'service-policies') {\n                targetNodes = this.processSearchInPreorder(this.nodes[1], searchTxt, paths, targetNodes);\n            } else if (this.resourceType === 'edge-routers') {\n                targetNodes = this.processSearchInPreorder(this.nodes[4], searchTxt, paths, targetNodes);\n            } else if (this.resourceType === 'services') {\n                targetNodes = this.processSearchInPreorder(this.nodes[2], searchTxt, paths, targetNodes);\n            } else if (this.resourceType === 'identities') {\n                targetNodes = this.processSearchInPreorder(this.nodes[3], searchTxt, paths, targetNodes);\n            } else if (this.resourceType === 'edge-router-policies') {\n                targetNodes = this.processSearchInPreorder(this.nodes[5], searchTxt, paths, targetNodes);\n            } else if (this.resourceType === 'service-edge-router-policies') {\n                targetNodes = this.processSearchInPreorder(this.nodes[6], searchTxt, paths, targetNodes);\n            }\n            paths = this.explorePathsForSearchedNodes(targetNodes, paths, nodeIds);\n            if (targetNodes && targetNodes.length <= 0) {\n                this.noSearchResults = true;\n                this.clearSearchLinkColors();\n               // return false;\n            } else {\n            //if (targetNodes) {\n                this.openPaths(paths, true);\n                // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n                // @ts-ignore\n                d3.selectAll('circle').filter(function (d: any) {\n                    const dataName = _.get(d, 'data.name', '');\n                    // const dataId = _.get(d, 'data.id', '');\n                    const nodeName = _.get(targetNodes[0], 'data.name', '');\n                    if (dataName.toLowerCase() === searchTxt.toLowerCase() && nodeName === dataName) {\n                        d3.select(this).style('fill', 'red');\n                    }\n                });\n            }\n            // else {\n             //   this.noSearchResults = true;\n              //  this.clearSearchLinkColors();\n             // }\n        }\n    }\n    explorePathsForSearchedNodes(targetNodes, paths, nodeIds) {\n        for (let i = 0; targetNodes && i < targetNodes.length; i++) {\n            let nd = targetNodes[i];\n            paths.push(nd);\n            while (nd.parent) {\n                const nodeId = _.get(nd.parent, 'data.id');\n                if (nodeIds.indexOf(nodeId) < 0) {\n                    nodeIds.push(nodeId);\n                    paths.push(nd.parent);\n                }\n                nd = nd.parent;\n            }\n        }\n        return paths;\n    }\n    processSearchInPreorder(nodeObj, searchTxt, paths, targetNodes) {\n        const name = _.get(nodeObj, 'data.name');\n        // const nodeId = _.get(nodeObj, 'data.id');\n        const isRootNode = _.get(nodeObj, 'data.rootNode');\n        if (!name) {\n            return;\n        }\n        if (isRootNode && isRootNode === 'Yes' && name.toLowerCase() === searchTxt.toLowerCase()) {\n            targetNodes.push(nodeObj);\n        }\n        const childNodes = nodeObj.children ? nodeObj.children : nodeObj._children;\n        for (let i = 0; childNodes && i < childNodes.length; i++) {\n            this.processSearchInPreorder(childNodes[i], searchTxt, paths, targetNodes);\n        }\n        return targetNodes;\n    }\n    clearSearchLinkColors() {\n        this.svg.selectAll('path.link').each( function (this: any,  d:any) {\n            d3.select(this).style('stroke', 'white');\n        });\n        this.svg.selectAll('circle').style('fill', function (d:any) {\n            return d._children ? 'var(--tableText)' : '#fff';\n        });\n    }\n\n    openPaths(paths, doReset = false) {\n        const pathIds = [];\n        for (let i = paths.length - 1; i >= 0; i--) {\n            const l = paths[i];\n            if (this.openNodes.indexOf(l.data.id) < 0) {\n                this.openNodes.push(l.data.id);\n            }\n            this.expand(paths[i]);\n            if (i > 0) {\n                this.updateTree(l, doReset);\n            }\n            pathIds.push(l.data.id);\n        }\n        pathIds.push(paths[1].data.id);\n        pathIds.push(paths[0].data.id);\n\n        let childreng = null; // get 2nd level data nodes.\n        if (this.resourceType === 'service-policies') {\n            childreng = this.networkGraph.children[0];\n        } else if (this.resourceType === 'services') {\n            childreng = this.networkGraph.children[1];\n        } else if (this.resourceType === 'identities') {\n            childreng = this.networkGraph.children[2];\n        } else if (this.resourceType === 'edge-routers') {\n            childreng = this.networkGraph.children[3];\n        } else if (this.resourceType === 'edge-router-policies') {\n            childreng = this.networkGraph.children[4];\n        } else if (this.resourceType === 'service-edge-router-policies') {\n            childreng = this.networkGraph.children[5];\n        }\n        const ndd_childs = childreng.children ? childreng.children : childreng._children; // 2nd level chailds. groups/childrens\n        for (let i = 0; i < ndd_childs.length; i++) {\n            // 2st level\n            //  if (this.resourceType === 'endpoints' || this.resourceType === 'services') {\n            if (ndd_childs[i].data.type === 'Group') {\n                // process groups\n                const d1 = ndd_childs[i]; //get group\n                if (d1 && paths[1].data.id === d1.data.id) {\n                    const children0 = d1.children ? d1.children : d1._children; // 3rd level childs\n                    const arr = children0.filter(function (replOb) {\n                        return replOb.data.id === paths[0].data.id;\n                    });\n                    d1.children = arr;\n                    d1._children = null;\n                    const arrgrp = ndd_childs.filter(function (replObj) {\n                        return replObj.data.id === d1.data.id;\n                    });\n                    childreng.children = arrgrp;\n                    this.updateTree(this.networkGraph, doReset);\n                    break;\n                }\n            } else {\n                if (childreng.data.id === paths[1].data.id) {\n                    const arr = ndd_childs.filter(function (replOb) {\n                        return replOb.data.id === paths[0].data.id;\n                    });\n                    childreng.children = arr;\n                    childreng._children = null;\n                    this.updateTree(this.networkGraph, doReset);\n                    break;\n                }\n            }\n        }\n        let datanodes = null; // get 2nd level data nodes.\n        if (this.resourceType === 'service-policies') {\n            datanodes = this.networkGraph.data.children[0];\n        } else if (this.resourceType === 'services') {\n            datanodes = this.networkGraph.data.children[1];\n        } else if (this.resourceType === 'identities') {\n            datanodes = this.networkGraph.data.children[2];\n        } else if (this.resourceType === 'edge-routers') {\n            datanodes = this.networkGraph.data.children[3];\n        } else if (this.resourceType === 'edge-router-policies') {\n            datanodes = this.networkGraph.data.children[4];\n        } else if (this.resourceType === 'service-edge-router-policies') {\n            datanodes = this.networkGraph.data.children[5];\n        }\n        if (datanodes.id === paths[1].data.id) {\n            const arr = datanodes.children.filter(function (replOb) {\n                return replOb.id === paths[0].data.id;\n            });\n            datanodes.children = arr;\n            this.updateTree(this.networkGraph, doReset);\n        } else {\n            const groupNodes = datanodes.children;\n            for (let k = 0; k < groupNodes.length; k++) {\n                if (groupNodes[k].id === paths[1].data.id) {\n                    // check searched group node\n                    const arr = groupNodes[k].children.filter(function (replOb) {\n                        return replOb.id === paths[0].data.id;\n                    });\n                    groupNodes[k].children = arr;\n                    const arrgrp = groupNodes.filter(function (replObj) {\n                        return replObj.id === paths[1].data.id;\n                    });\n                    datanodes.children = arrgrp;\n                    this.updateTree(this.networkGraph, doReset);\n                    break;\n                }\n            }\n        }\n\n        this.updateTree(this.networkGraph, doReset);\n        this.searchRootNode = paths[1];\n\n        this.svg.selectAll('.link').each(function (this:any, d:any) {\n            if (pathIds.indexOf(d.data.id) >= 0) {\n                d3.select(this).style('stroke', 'red');\n            } else {\n                d3.select(this).style('stroke', 'white');\n            }\n        });\n    }\n\n    resetSearchNode() {\n        if (this.searchRootNode) {\n            this.networkGraph = _.cloneDeep(this.baseNetworkGraph);\n            this.updateTree(this.networkGraph);\n        }\n    }\n\n    resetTree(clearSearch) {\n        this.resetSearchNode();\n        if (clearSearch) {\n            this.clearSearchFilter();\n            this.clearSearchType();\n        }\n        for (let i = this.openNodes.length - 1; i > 0; i--) {\n            const d = this.openNodes[i];\n            if (d && d.children) {\n                d._children = d.children;\n                d.children = null;\n                this.updateTree(d);\n            }\n        }\n        for (let i = this.nodes.length - 1; i > 0; i--) {\n            const d = this.nodes[i];\n            if (d && d.children) {\n                d._children = d.children;\n                d.children = null;\n                this.updateTree(d);\n            }\n        }\n\n        this.clearSearchLinkColors();\n        this.openNodes = [];\n        this.sizeToFit();\n        this.resetZoom();\n    }\n    expand(d) {\n        if (d._children) {\n            d.children = d._children;\n            d._children = null;\n        }\n    }\n\n    collapse() {\n        for (let i = this.openNodes.length - 1; i > 0; i--) {\n            const d = this.nodes[i];\n            if (d.children) {\n                d._children = d.children;\n                d.children = null;\n                this.updateTree(d);\n            }\n        }\n    }\n\n   filterSearchArray() {\n        if (_.isEmpty(this.resourceType)) {\n            this.autocompleteOptions = [];\n            this.resourceTypeError = !_.isEmpty(this.filterText);\n            return;\n        }\n        this.autocompleteOptions = [];\n        if (this.resourceType === 'service-policies') {\n            this.autocompleteOptions = this.servicePoliciesTreeNodes.filter((option) =>\n                option.toLowerCase().includes(this.filterText.toLowerCase())\n            );\n        } else if (this.resourceType === 'services') {\n            this.autocompleteOptions = this.servicesTreeNodes.filter((option) =>\n                option.toLowerCase().includes(this.filterText.toLowerCase())\n            );\n        } else if (this.resourceType === 'identities') {\n            this.autocompleteOptions = this.identitiesTreeNodes.filter((option) =>\n                option.toLowerCase().includes(this.filterText.toLowerCase())\n            );\n        } else if (this.resourceType === 'edge-routers') {\n            this.autocompleteOptions = this.edgeroutersTreeNodes.filter((option) =>\n                option.toLowerCase().includes(this.filterText.toLowerCase())\n            );\n        } else if (this.resourceType === 'edge-router-policies') {\n            this.autocompleteOptions = this.erPoliciesTreeNodes.filter((option) =>\n                option.toLowerCase().includes(this.filterText.toLowerCase())\n            );\n        } else if (this.resourceType === 'service-edge-router-policies') {\n            this.autocompleteOptions = this.serviceEdgeRouterPolicyTreeNodes.filter((option) =>\n                option.toLowerCase().includes(this.filterText.toLowerCase())\n            );\n        }\n   }\n   zoomIn() {\n\n   }\n   zoomOut() {\n\n   }\n    clearSearchFilter() {\n        this.resourceTypeError = false;\n        this.filterText = '';\n        this.filterSearchArray();\n        this.resetSearchNode();\n        this.collapse();\n        this.clearSearchLinkColors();\n    }\n\n    clearSearchType() {\n        this.resourceType = '';\n        this.autocompleteOptions = [];\n    }\n\n   resetZoom() {\n       // const currentZoom = this.getZoomScale();\n       const transform: any = this.transform || _.cloneDeep(d3.zoomIdentity);\n       transform.k = 1;\n       this.svg.attr('transform', transform);\n   }\n\n  initTopoView() {\n        this.autocompleteOptions = [];\n        const margin = { top: 20, right: 190, bottom: 30, left: 0 };\n        // const width = 1600 - margin.left - margin.right;\n        const width = window.innerWidth -  margin.right;\n        // const height = 1600 - margin.top - margin.bottom;\n        const height = window.innerHeight - margin.bottom;\n\n        this.treetooltip = d3.select('#tooltip');\n\n        this.resourceTypeError = false;\n        this.filterText = '';\n        this.resourceType = '';\n\n        const handleZoom = (e) => {\n            this.svg.attr('transform', e.transform);\n        };\n        this.zoom = d3.zoom().on('zoom', handleZoom);\n\n        this.svg = d3\n            .select('#NetworkVisualizerSVG')\n            .attr('width', '100%')\n            .attr('height', '100%')\n            .call(this.zoom)\n            .attr('viewBox', '-20 -450 ' + (width - margin.top*2 - margin.bottom) + ' ' + +(height*2 -margin.bottom))\n            .append('g')\n            .attr('transform', 'translate(' + -20 + ',' + 200 + ')');\n\n        d3.select('body').on('click', function () {\n            d3.select('#topocontextmenu').style('display', 'none');\n        });\n\n        d3.selectAll('g > *').remove();\n\n        this.treemap = d3.tree().nodeSize([100, 20]);\n\n        this.networkGraph.x = 100; // height / 4;\n        this.networkGraph.y = 100;\n        this.networkGraph.children.forEach(collapse);\n        this.updateTree(this.networkGraph);\n\n        _.delay(() => {\n            this.transform = d3.zoomIdentity;\n            this.transform.x = -200;\n            this.transform.y = 205;\n            this.transform.k = 1;\n            this.svg.transition().duration(750).attr('transform', this.transform);\n        }, 600);\n\n        function collapse(d) {\n            if (d.data.rootNode === 'Yes') {\n                d.data.clickProcess = 'Not Yet';\n                d._children = null;\n            }\n            if (d.children) {\n                d._children = d.children;\n                d._children.forEach(collapse);\n                d.children = null;\n            }\n        }\n  }\n\n    updateTree(source, doReset = false) {\n        if (doReset) {\n            d3.selectAll('g > *').remove();\n        }\n        const duration = 750;\n        try {\n            this.treeData = this.treemap(this.networkGraph);\n            this.nodes = this.treeData.descendants();\n            this.links = this.treeData.descendants().slice(1);\n        } catch (e:any) {\n          this.logger.error('Error in building tree object: '+ e.message);\n        }\n        const svgDefs = this.svg.append('defs');\n        const linearGradient = svgDefs.append('linearGradient').attr('id', 'NodeGradient');\n        linearGradient.append('stop').attr('class', 'stop1').attr('offset', '0%');\n        linearGradient.append('stop').attr('class', 'stop2').attr('offset', '50%');\n        linearGradient.append('stop').attr('class', 'stop3').attr('offset', '100%');\n\n        const linearGradient2 = svgDefs.append('linearGradient').attr('id', 'NodeHoverGradient');\n        linearGradient2.append('stop').attr('class', 'stop1a').attr('offset', '0%');\n        linearGradient2.append('stop').attr('class', 'stop2a').attr('offset', '50%');\n        linearGradient2.append('stop').attr('class', 'stop3a').attr('offset', '100%');\n\n        this.nodes.forEach(function (d) {\n            d.y = d.depth * 400;\n        });\n        this.node = this.svg.selectAll('g.node').data(this.nodes, function (d) {\n            return d.data.id;\n        });\n\n        this.nodeEnter = this.node\n            .enter()\n            .append('g')\n            .attr('class', (d) => {\n                let className = '';\n\n                if (_.startsWith(d.data.name, 'Edge Routers') || _.includes(d.data.type, 'Edge Router')) {\n                    className = 'edge-router';\n                }\n                if (_.includes(d.data.name, 'Identities') || _.includes(d.data.type, 'Identity')) {\n                    className = 'endpoint';\n                }\n                if (_.startsWith(d.data.name, 'Services') || _.startsWith(d.data.type, 'Service')) {\n                    className = 'service';\n                }\n                if (_.startsWith(d.data.name, 'Bind-Services') || _.startsWith(d.data.name, 'Dial-Services')) {\n                    className = 'service';\n                }\n                if (_.startsWith(d.data.name, 'BindPolicies') || _.startsWith(d.data.name, 'DialPolicies') || _.startsWith(d.data.name, 'BindPolicy') ) {\n                     className = 'service-policy';\n                }\n                if (_.includes(d.data.name, 'Service Policies') || _.includes(d.data.type, 'ServicePolicy')) {\n                    className = 'service-policy';\n                }\n                if (_.startsWith(d.data.name, 'Edge Router Policies') || _.startsWith(d.data.type, 'Router Policy')) {\n                    className = 'edge-router-policy';\n                }\n                if (\n                    _.startsWith(d.data.name, 'Service Edge Router Policies') ||\n                    _.startsWith(d.data.type, 'Service Router Policy')\n                ) {\n                    className = 'service-edge-router-policy';\n                }\n\n                className = d._children ? 'node ' + className : 'node terminate ' + className;\n\n                return className;\n            })\n            .attr('transform', function (d) {\n                if (source && source.x) {\n                    return 'translate(' + source.y + ',' + source.x + ')';\n                } else {\n                    return 'translate(' + d.y + ',' + d.x + ')';\n                }\n            });\n\n        this.nodeEnter.on('contextmenu', (event, d) => {\n            event.preventDefault();\n            d3.select('#tooltip').style('display', 'none');\n            const nw = this.currentNetwork;\n            const rawEdgerouters = this.edgerouters;\n            const rawEndpoints = this.identities;\n            const rawAppwans = this.service_policies;\n            const edgeRouterPolicies = this.router_policies;\n\n            if (d && d.data && d.data.contextMenu === 'Yes') {\n                d3.select('#topocontextmenu')\n                    .style('position', 'absolute')\n                    .style('left', event.offsetX + 'px')\n                    .style('top', event.offsetY + 'px')\n                    .style('display', 'block');\n            } else {\n                return;\n            }\n            let obj = null;\n            if (d && d.data && d.data.type === 'Identity') {\n               if(d.data.status === \"Registered\") {\n                  enableLi('#liSingleUT');\n                  enableLi('#liFLSingleRouter');\n                  enableLi('#liSingleLT');\n               } else {\n                  disableLi('#liSingleUT');\n                  disableLi('#liFLSingleRouter');\n                  disableLi('#liSingleLT');\n               }\n                enableLi('#liMet');\n                enableLi('#liVC');\n                enableLi('#liEV');\n                disableLi('#liIns');\n                disableLi('#liAL');\n                disableLi('#liEPs');\n                disableLi('#liFLAll');\n                disableLi('#liFLSingleRouter');\n                disableLi('#liSingleLT');\n                disableLi('#liCL');\n                disableLi('#liLT');\n                /*\n                obj = new Identity();\n                for (let i = 0; i < rawEndpoints.length; i++) {\n                    if (rawEndpoints[i].id === d.data.uuid) {\n                        obj = rawEndpoints[i];\n                    }\n                }\n                */\n                this.contextmenuNodeType = 'identity';\n            } else if (d && d.data && d.data.type === 'Edge Router') {\n              if(d.data.status === \"PROVISIONED\") {\n                enableLi('#liSingleUT');\n                enableLi('#liFLSingleRouter');\n                enableLi('#liSingleLT');\n              } else {\n                disableLi('#liSingleUT');\n                disableLi('#liFLSingleRouter');\n                disableLi('#liSingleLT');\n                }\n                enableLi('#liMet');\n                enableLi('#liVC');\n                disableLi('#liIns');\n                disableLi('#liEV');\n                enableLi('#liAL');\n                disableLi('#liEPs');\n                disableLi('#liFLAll');\n\n                disableLi('#liCL');\n                disableLi('#liLT');\n                this.contextmenuNodeType = 'edge-router';\n                /*\n                obj = new EdgeRouterV2();\n                for (let i = 0; i < rawEdgerouters.length; i++) {\n                    if (rawEdgerouters[i].id === d.data.uuid) {\n                        obj = rawEdgerouters[i];\n                    }\n                }\n                */\n            } else if (d && d.data && d.data.type === 'Service') {\n                enableLi('#liMet');\n                enableLi('#liVC');\n                disableLi('#liIns');\n                disableLi('#liEV');\n                disableLi('#liAL');\n                enableLi('#liEPs');\n                disableLi('#liFLAll');\n                disableLi('#liFLSingleRouter');\n                disableLi('#liSingleLT');\n                disableLi('#liCL');\n                disableLi('#liLT');\n                enableLi('#liSingleUT');\n                this.contextmenuNodeType = 'service';\n                /*\n                obj = new PlatformService();\n                for (let i = 0; i < this.services.length; i++) {\n                    if (this.services[i].id === d.data.uuid) {\n                        obj = this.services[i];\n                    }\n                }\n                */\n            } else if (d && d.data && d.data.type === 'AppWAN') {\n                disableLi('#liMet');\n                enableLi('#liVC');\n                disableLi('#liIns');\n                disableLi('#liEV');\n                disableLi('#liAL');\n                disableLi('#liEPs');\n                disableLi('#liFLAll');\n                disableLi('#liFLSingleRouter');\n                disableLi('#liSingleLT');\n                disableLi('#liCL');\n                disableLi('#liLT');\n                disableLi('#liSingleUT');\n                /*\n                obj = new ServicePolicy();\n                for (let i = 0; i < rawAppwans.length; i++) {\n                    if (rawAppwans[i].id === d.data.uuid) {\n                        obj = rawAppwans[i];\n                    }\n                }\n                */\n                this.contextmenuNodeType = 'appwan';\n            } else if (d && d.data && d.data.type === 'Router Policy') {\n                disableLi('#liMet');\n                disableLi('#liIns');\n                enableLi('#liVC');\n                disableLi('#liEV');\n                disableLi('#liAL');\n                disableLi('#liEPs');\n                disableLi('#liFLSingleRouter');\n                disableLi('#liSingleLT');\n                disableLi('#liFLAll');\n                disableLi('#liCL');\n                disableLi('#liLT');\n                disableLi('#liSingleUT');\n                this.contextmenuNodeType = 'router-policy';\n             /*\n              obj = new EdgeRouterPolicyV2();\n                for (let i = 0; i < edgeRouterPolicies.length; i++) {\n                    if (edgeRouterPolicies[i].id === d.data.uuid) {\n                        obj = edgeRouterPolicies[i];\n                    }\n                }\n              */\n            } else if (d && d.data && d.data.type === 'Network') {\n                enableLi('#liMet');\n                disableLi('#liIns');\n                enableLi('#liVC');\n                disableLi('#liEV');\n                enableLi('#liAL');\n                disableLi('#liEPs');\n                enableLi('#liFLAll');\n                disableLi('#liFLSingleRouter');\n                disableLi('#liSingleLT');\n                enableLi('#liCL');\n                enableLi('#liLT');\n                disableLi('#liSingleUT');\n                this.contextmenuNodeType = 'network';\n                obj = nw;\n            } else if (d && d.data && d.data.type === 'Service Router Policy') {\n                disableLi('#liMet');\n                disableLi('#liIns');\n                enableLi('#liVC');\n                disableLi('#liEV');\n                disableLi('#liAL');\n                disableLi('#liEPs');\n                disableLi('#liFLAll');\n                disableLi('#liFLSingleRouter');\n                disableLi('#liSingleLT');\n                disableLi('#liCL');\n                disableLi('#liLT');\n                disableLi('#liSingleUT');\n                this.contextmenuNodeType = 'service-router-policy';\n               /*\n                obj = new ServiceEdgeRouterPolicy();\n                for (let i = 0; i < this.service_router_policies.length; i++) {\n                    if (this.service_router_policies[i].id === d.data.uuid) {\n                        obj = this.service_router_policies[i];\n                    }\n                }\n                */\n            }\n            this.contextmenuNode = obj;\n            d3.select('#tooltip').style('display', 'none');\n        });\n\n        this.circles = this.nodeEnter\n            .append('circle')\n            .attr('class', 'node')\n            .attr('r', 10)\n            .style('fill', function (d) {\n                return d._children ? 'var(--tableText)' : '#fff';\n            })\n            .on('mousemove', (event, source) => {\n                this.drawTreeTooltip(event, source);\n            })\n            .on('mouseout', this.removeTreeTooltip)\n            .on('contextmenu', (event) => {\n                event.preventDefault();\n            })\n            .on('click', async (event, d) => {\n                if (d && d.data && d.data.contextMenu === 'Yes') {\n                    d3.select('#topocontextmenu').style('display', 'none');\n                }\n                d3.select('#tooltip').style('display', 'none');\n                if (d.children && d.children.length > 0) {\n                    const index = this.openNodes.indexOf(d.data.id, 0);\n                    if (index > -1) {\n                        this.openNodes.splice(index, 1);\n                    }\n                    d._children = d.children;\n                    d.children = null;\n                } else {\n                    if (this.openNodes.indexOf(d.data.id) < 0) {\n                        this.openNodes.push(d.data.id);\n                    }\n                    if (d.data.clickProcess === 'Not Yet') {\n                        d._children = null;\n                        if (\n                            d.data &&\n                            d.data.rootNode &&\n                            d.data.rootNode === 'Yes' &&\n                            d.data.type === 'Identity' &&\n                            !d.children &&\n                            !d._children\n                        ) {\n                            const arr =  await this.treeNodeProcessor.processIdentitiesForNodeClick(\n                                d,\n                                this.networkGraph,\n                                this.identities,\n                                this.uniqId,\n                                this.zitiService,\n                                this.configs\n                            );\n                            this.uniqId = arr[1];\n                            this.networkGraph = arr[0];\n\n                            d.data.clickProcess = 'Completed';\n                            this.networkGraph.children.find((nd) => {\n                                collapseFew(nd, this.openNodes);\n                            });\n                            this.updateTree(d);\n                        } else if (\n                            d.data &&\n                            d.data.rootNode &&\n                            d.data.rootNode === 'Yes' &&\n                            d.data.type === 'Service' &&\n                            !d.children &&\n                            !d._children\n                        ) {\n                            const arr = await this.treeNodeProcessor.processServicesForNodeClick(\n                                d,\n                                this.networkGraph,\n                                this.services,\n                                this.uniqId,\n                                this.zitiService\n                            );\n                            this.uniqId = arr[1];\n                            this.networkGraph = arr[0];\n                            d.data.clickProcess = 'Completed';\n                            this.networkGraph.children.find((nd) => {\n                                collapseFew(nd, this.openNodes);\n                            });\n                            this.updateTree(d);\n                        } else if (\n                            d.data &&\n                            d.data.rootNode &&\n                            d.data.rootNode === 'Yes' &&\n                            d.data.type === 'ServicePolicy' &&\n                            !d.children &&\n                            !d._children\n                        ) {\n                            const arr = await this.treeNodeProcessor.processServicePoliciesForNodeClick(\n                                d,\n                                this.networkGraph,\n                                this.service_policies,\n                                this.uniqId,\n                                this.zitiService\n                            );\n                            this.uniqId = arr[1];\n                            this.networkGraph = arr[0];\n                            d.data.clickProcess = 'Completed';\n                            this.networkGraph.children.find((nd) => {\n                                collapseFew(nd, this.openNodes);\n                            });\n                            this.updateTree(d);\n                        } else if (\n                            d.data &&\n                            d.data.rootNode &&\n                            d.data.rootNode === 'Yes' &&\n                            d.data.type === 'Edge Router' &&\n                            !d.children &&\n                            !d._children\n                        ) {\n                            const arr = await this.treeNodeProcessor.processEdgeroutersForNodeClick(\n                                d,\n                                this.networkGraph,\n                                this.edgerouters,\n                                this.uniqId,\n                                this.zitiService\n                            );\n                            this.uniqId = arr[1];\n                            this.networkGraph = arr[0];\n                            d.data.clickProcess = 'Completed';\n                            this.networkGraph.children.find((nd) => {\n                                collapseFew(nd, this.openNodes);\n                            });\n                            this.updateTree(d);\n                        } else if (\n                            d.data &&\n                            d.data.rootNode &&\n                            d.data.rootNode === 'Yes' &&\n                            d.data.type === 'Router Policy' &&\n                            !d.children &&\n                            !d._children\n                        ) {\n                            const arr = await this.treeNodeProcessor.processEdgeRouterPoliciesForNodeClick(\n                                d,\n                                this.networkGraph,\n                                this.router_policies,\n                                this.uniqId,\n                                this.zitiService\n                            );\n                            this.uniqId = arr[1];\n                            this.networkGraph = arr[0];\n                            d.data.clickProcess = 'Completed';\n                            this.networkGraph.children.find((nd) => {\n                                collapseFew(nd, this.openNodes);\n                            });\n                            this.updateTree(d);\n                        } else if (\n                            d.data &&\n                            d.data.rootNode &&\n                            d.data.rootNode === 'Yes' &&\n                            d.data.type === 'Service Router Policy' &&\n                            !d.children &&\n                            !d._children\n                        ) {\n                            const arr = await this.treeNodeProcessor.processServiceEdgeRouterPoliciesForNodeClick(\n                                d,\n                                this.networkGraph,\n                                this.service_router_policies,\n                                this.uniqId,\n                                this.zitiService\n                            );\n\n                            this.uniqId = arr[1];\n                            this.networkGraph = arr[0];\n                            d.data.clickProcess = 'Completed';\n                            this.networkGraph.children.find((nd) => {\n                                collapseFew(nd, this.openNodes);\n                            });\n                            this.updateTree(d);\n                        } else {\n                            d.children = d._children;\n                        }\n                    } else {\n                        d.children = d._children;\n                    }\n                    if (d._children) {\n                        d._children = null;\n                    }\n                }\n\n                if (d.children || d._children) {\n                    this.updateTree(d);\n                }\n\n                const rootNode = _.get(d, 'data.children[0].rootNode', '');\n                const subrootNode = _.get(d, 'data.rootNode', '');\n                if (rootNode === 'Yes' || subrootNode === 'Yes') {\n                    rootNodeisYesColorChange();\n                }\n            });\n\n        this.nodeEnter\n            .append('foreignObject')\n            .attr('height', '50')\n            .attr('width', '330')\n            .attr('x', '10')\n            .attr('y', '-25')\n            .append('xhtml:body')\n            .style('background', 'transparent')\n            .html(function (d) {\n                return `<div class=\"text-container\"<span>${d.data.name}</span>`;\n            });\n\n        this.nodeUpdate = this.nodeEnter.merge(this.node);\n\n        this.nodeUpdate\n            .transition()\n            .duration(duration)\n            .attr('transform', function (d) {\n                return 'translate(' + d.y + ',' + d.x + ')';\n            });\n\n        this.nodeUpdate.select('circle.node').attr('r', 18).attr('cursor', 'pointer');\n\n        this.nodeExit = this.node\n            .exit()\n            .transition()\n            .duration(duration)\n            .attr('transform', function (d) {\n                if (source && source.x) {\n                    return 'translate(' + source.y + ',' + source.x + ')';\n                } else {\n                    return 'translate(' + d.y + ',' + d.x + ')';\n                }\n            })\n            .remove();\n\n        this.nodeExit.select('circle').attr('r', 0);\n\n        this.nodeExit.select('text').style('fill-opacity', 10);\n\n        this.link = this.svg.selectAll('path.link').data(this.links, function (d) {\n            return d.data.id;\n        });\n        this.linkUpdate = this.link\n            .enter()\n            .insert('path', 'g')\n            .attr('class', 'link')\n            .attr('d', function (d) {\n                let o;\n                if (source && source.x) {\n                    o = { x: source.x, y: source.y };\n                } else {\n                    o = { x: d.x, y: d.y };\n                }\n                return diagonal(o, o, '1');\n            })\n            .merge(this.link);\n\n        this.linkUpdate\n            .transition()\n            .duration(duration)\n            .attr('d', function (d) {\n                return diagonal(d, d.parent, '2');\n            });\n\n        this.linkExit = this.link\n            .exit()\n            .transition()\n            .duration(duration)\n            .attr('d', function (d) {\n                let o;\n                if (source && source.x) {\n                    o = { x: source.x, y: source.y };\n                } else {\n                    o = { x: d.x, y: d.y };\n                }\n                return diagonal(o, o, '3');\n            })\n            .remove();\n\n        this.nodes.forEach(function (d: any) {\n            d.x0 = d.x;\n            d.y0 = d.y;\n        });\n\n        function disableLi(liId) {\n            d3.select(liId).style('display', 'none');\n        }\n\n        function enableLi(liId) {\n            d3.select(liId).style('display', 'block');\n        }\n\n        function diagonal(s, d, lg) {\n            const path = `M ${s.y} ${s.x}\n             C ${(s.y + d.y) / 2} ${s.x},\n               ${(s.y + d.y) / 2} ${d.x},\n               ${d.y} ${d.x}`;\n\n            return path;\n        }\n\n        function rootNodeisYesColorChange() {\n            d3.selectAll('circle').each(function (d: any) {\n                const rootNode = _.get(d, 'data.rootNode', '');\n                const clickProcess = _.get(d, 'data.clickProcess', '');\n                if (rootNode === 'Yes' && clickProcess === 'Not Yet') {\n                    d3.select(this).style('fill', 'brown');\n                } else if (rootNode === 'Yes' && clickProcess !== 'Not Yet') {\n                    const color = d._children ? 'var(--tableText)' : '#fff';\n                    d3.select(this).style('fill', color);\n                }\n            });\n        }\n\n        function collapseDepth(d, id) {\n            // unused\n            if (d.children) {\n                if (d.data.id !== id) {\n                    d._children = d.children;\n                    d._children.forEach(collapseDepth);\n                    d.children = null;\n                } else {\n                    d.children.forEach(collapseDepth);\n                }\n            }\n        }\n\n        function collapseFew(_nd, openNodes) {\n            if (_nd.data.id === '#all') {\n                return;\n            }\n            if (_nd.data.rootNode === 'Yes' && _nd.data.clickProcess === 'Not Yet') {\n                _nd._children = [];\n            }\n            if (_nd.children && openNodes.indexOf(_nd.data.id) < 0) {\n                _nd._children = _nd.children;\n                if (_nd._children)\n                    _nd._children.find((_nd) => {\n                        collapseFew(_nd, openNodes);\n                    });\n                _nd.children = null;\n            }\n\n            if (_nd.children && openNodes.indexOf(_nd.data.id) >= 0) {\n                if (_nd.children)\n                    _nd.children.find((_nd) => {\n                        collapseFew(_nd, openNodes);\n                    });\n            }\n        }\n\n        if (source.children === null) {\n            _.delay(this.sizeToFit.bind(this), 650);\n        }\n    } // end of updateTree\n\n    sizeToFit() {\n        const boundingBox = this.svg._groups[0][0].getBoundingClientRect();\n        const bottomDelta = boundingBox.height - 100 - -boundingBox.top;\n        const topDelta = boundingBox.height + 500 - boundingBox.bottom;\n        const topOutOfView = topDelta < 0;\n        const bottomOutOfView = bottomDelta < 0;\n\n        if (bottomOutOfView || topOutOfView) {\n            const trans = this.transform;\n            trans.y = topOutOfView ? 400 : 0;\n            this.svg.transition().duration(750).attr('transform', trans);\n        }\n    }\n    removeGraphTooltip() {\n        if (this.graphtooltip) {\n            this.graphtooltip.style('display', 'none');\n        }\n    }\n\n    drawGraphTooltip(event, d) {\n        document.getElementById('tooltip').innerHTML = this.readGraphKeyValues(d);\n        this.graphtooltip.style('display', 'block');\n        const x = event.pageX - 400 + 'px';\n        const y = event.pageY + 10 + 'px';\n        this.graphtooltip.style('left', x);\n        this.graphtooltip.style('top', y);\n    }\n\n    readGraphKeyValues(d) {\n        let info =\n            '<span style=\"font-size:14px;font-family:Open Sans; font-weight: 600; font-color: var(--tableText);\">';\n        const keys = Object.keys(d.data);\n        keys.forEach( (k) => {\n            if (\n                k === 'value' ||\n                k === 'group' ||\n                k === 'index' ||\n                k === 'parent' ||\n                k === 'depth' ||\n                k === 'x' ||\n                k === 'y' ||\n                k === 'id' ||\n                k === 'x0' ||\n                k === 'y0' ||\n                k === 'vy' ||\n                k === 'vx'\n            ) {\n                // continue;\n            } else if (k === 'children') {\n                const kVal: any = d.data[k];\n                info = info + '  ' + k + '  :  ' + kVal.length + '<br>';\n            } else {\n                if (this.isAnObject(d.data[k])) {\n                    const kVal: any = d.data[k];\n                    info = info + '   ' + k + '  :  ' + kVal.name + '<br>';\n                } else {\n                    const vo = d.data[k];\n                    info = info + '   ' + k + '  :  ' + (vo !== null || vo !== '' ? d.data[k] : 'N/A') + '<br>';\n                }\n            }\n        });\n        return info + '</span>';\n    }\n\n    setColor(d) {\n        if (d.status === 'Error' && d.group === 3) {\n            return 'red';\n        } else if (d.status !== 'Error' && d.group === 3) {\n            return 'var(--tableText)';\n        } else {\n            return 'var(--tableText)';\n        }\n    }\n\n    ticked() {\n        this.links\n            .attr('x1', function (d) {\n                return d.source.x;\n            })\n            .attr('y1', function (d) {\n                return d.source.y;\n            })\n            .attr('x2', function (d) {\n                return d.target.x;\n            })\n            .attr('y2', function (d) {\n                return d.target.y;\n            });\n\n        this.nodes.attr('transform', function (d) {\n            return 'translate(' + d.x + ',' + d.y + ')';\n        });\n    }\n\n    isAnObject(o) {\n        return o instanceof Object && o.constructor === Object;\n    }\n\n    readObjectValues(linkObject) {\n        let info = '<span style=\"font-size:12px;font-family: sans-serif\">';\n        const keys = Object.keys(linkObject.data);\n        keys.forEach( (k) => {\n            if (this.isAnObject(linkObject.data[k])) {\n                const kVal: any = linkObject.data[k];\n                info = info + '   ' + k + '  :  ' + kVal.id + '<br>';\n            } else {\n                info = info + '   ' + k + '  :  ' + linkObject.data[k] + '<br>';\n            }\n        });\n        return info + '</span>';\n    }\n\n    nodeColor(d) {\n        if (d.status === 'Error') {\n            return '#FF0000';\n        } else {\n            return 'blue';\n        }\n    }\n\n    nodeshape(d) {\n        if (d.group === '3') {\n            return 'rect';\n        } else {\n            return 'circle';\n        }\n    }\n\n    linkWidth(d) {\n        if (d.group === 1) {\n            return 10;\n        } else {\n            return 2;\n        }\n    }\n\n    dragstarted(event, d) {\n        if (!event.active) {\n            this.simulation.alphaTarget(0.3).restart();\n        }\n        d.fx = d.x;\n        d.fy = d.y;\n    }\n\n    dragged(d) {\n        d.fx = d.x;\n        d.fy = d.y;\n    }\n\n    dragended(event, d) {\n        if (!event.active) {\n            this.simulation.alphaTarget(0);\n        }\n\n        d.fx = null;\n        d.fy = null;\n    }\n    removeTreeTooltip() {\n        this.treetooltip = d3.select('#tooltip');\n        if (this.treetooltip) {\n            this.treetooltip.style('display', 'none');\n        }\n    }\n    drawTreeTooltip(event, s) {\n        this.treetooltip = d3.select('#tooltip');\n        this.treetooltip.style('display', 'block');\n        const x = event.pageX + 'px';\n        const y = event.pageY + 15 + 'px';\n        this.treetooltip.style('left', x);\n        this.treetooltip.style('top', y);\n        document.getElementById('tooltip').innerHTML = this.readTreeKeyValues(event, s);\n    }\n    readTreeKeyValues(event, d) {\n        let info = '<span>';\n        const keys = Object.keys(d.data); // mp.keys();\n        keys.forEach(function (k) {\n            if (\n                k === 'protocol' ||\n                k === 'contextMenu' ||\n                k === 'uuid' ||\n                k === 'lastId' ||\n                k === 'clickProcess' ||\n                k === 'rootNode' ||\n                k === 'id' ||\n                k === 'children' ||\n                k === 'parent' ||\n                k === 'depth' ||\n                k === 'x' ||\n                k === 'y' ||\n                k === 'rootNode' ||\n                k === 'x0' ||\n                k === 'y0'\n            ) {\n                // continue;\n            } else {\n                info = info + '   ' + k + '  :  ' + d.data[k] + '<br>';\n            }\n        });\n        return info + '</span>';\n    }\n\n  hide() {}\n  toggleModalSize() {};\n}\n\n","<div class=\"ziti-page-container ziti-identities-container\">\n\n    <div class=\"nf-network-topology-container\" >\n\n      <div class=\"css-header\">{{title}} </div><br>\n\n      <div  class=\"nf-net-vis-controls-header\">\n        <div class=\"nf-topology-zoom-container\">\n          <!--button (click)=\"zoomOut()\" class=\"nf-topology-zoom-button minus\"></button>\n          <button (click)=\"zoomIn()\" class=\"nf-topology-zoom-button plus\"></button-->\n          <div (click)=\"resetTree('Yes')\" class=\"reset-button\" title=\"Reset\"></div>\n        </div>\n        <select\n            (change)=\"resourceTypeChanged()\"\n            [(ngModel)]=\"resourceType\"\n            [ngClass]=\"{ 'resource-type-error': resourceTypeError }\"\n            class=\"resource-type-select\"\n            id=\"ResourceTypeSelect\"\n        >\n          <option value=\"\">Select Resource Type</option>\n          <option value=\"service-policies\">Service Policies</option>\n          <option value=\"services\">Services</option>\n          <option value=\"identities\">Identities</option>\n          <option value=\"edge-routers\">Edge Routers</option>\n          <option value=\"edge-router-policies\">Edge Router Policies</option>\n          <option value=\"service-edge-router-policies\">Service Edge Router Policies</option>\n        </select>\n        <div class=\"nf-net-vis-filter-container listBox row\">\n          <input\n              (keyup)=\"filterSearchArray()\"\n              [(ngModel)]=\"filterText\"\n              [matAutocomplete]=\"auto\"\n              class=\"nf-topology-filter-input\"\n              id=\"filterText\"\n              matInput\n              placeholder=\"Type to Filter\"\n          />\n\n          <div\n              (click)=\"clearSearchFilter()\"\n              *ngIf=\"filterText !== ''\"\n              class=\"buttonBall close\"\n              id=\"ClearSearchFilter\"\n          ></div>\n          <div [hidden]=\"!noSearchResults\" class=\"no-results-warning\">No Results Found</div>\n          <mat-autocomplete #auto=\"matAutocomplete\" (optionSelected)=\"autocompleteSearch($event)\">\n            <mat-option *ngFor=\"let option of autocompleteOptions\" [value]=\"option\">\n              {{ option }}\n            </mat-option>\n          </mat-autocomplete>\n        </div>\n      </div>\n\n      <div class=\"nf-topology-legend\">\n        <div class=\"legend-item\">\n          <div class=\"legend-circle servicepolicies\"></div>\n          <div class=\"legend-text\">Service Policies</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle services\"></div>\n          <div class=\"legend-text\">Services</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle endpoints\"></div>\n          <div class=\"legend-text\">Identities</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle edgerouters\"></div>\n          <div class=\"legend-text\">Edge Routers</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle erpolicies\"></div>\n          <div class=\"legend-text\">Edge Router Policies</div>\n        </div>\n        <div class=\"legend-item\">\n          <div class=\"legend-circle serviceerpolicies\"></div>\n          <div class=\"legend-text\">Service Router Policies</div>\n        </div>\n      </div>\n\n      <div class=\"topotip\" id=\"tooltip\"></div>\n      <svg style='pointer-events:all' id=\"NetworkVisualizerSVG\"></svg>\n      <lib-loading-indicator *ngIf=\"isLoading\" [isLoading]=\"isLoading\"></lib-loading-indicator>\n    </div>\n\n</div>\n"]}