member_webapp/src/packages/infra/component/map/map.component.ts

import {
  Component,
  OnInit,
  AfterViewInit,
  AfterContentInit,
  ViewChild
} from '@angular/core';
import { Router } from '@angular/router';
import { TreeNode } from 'primeng/primeng';
import { Store, select } from '@ngrx/store';
import * as ListStore from '../../store/list';
import { ListSelector } from '../../store';
import { Page } from 'app/commons/model';
import { RPCClientError } from '@loafer/ng-rpc/protocol';
import { Target } from 'packages/target/model';
import { Infra, InfraHost, InfraOSApplication, InfraService } from '../../model';

interface HostData {
  id: string;
  target?: Target;
  host: InfraHost;
  services: InfraService[];
}

@Component({
  selector: 'of-infra-map',
  templateUrl: './map.component.html'
})
export class MapComponent implements OnInit, AfterContentInit {
  infraTree: TreeNode[] = testInfraList;

  infras$ = this.listStore.pipe(select(ListSelector.select('page')));

  display = false;
  loading = false;

  totalList: Infra[];
  hostDataList: HostData[] = new Array();

  DEFAULT_EXPANDED: Boolean = true;

  constructor(private router: Router,
    private listStore: Store<ListStore.State>,
  ) {}

  ngAfterContentInit() {

    this.infras$.subscribe(
      (page: Page) => {
        if (page !== null) {
          this.totalList = page.content;
          this.generateInfraHostData();
        }
      },
      (error: RPCClientError) => {
        console.log(error.response.message);
      });
  }

  ngOnInit() {}


  generateInfraHostData(filterStr?: string) {

    const itl: TreeNode[] = [];

    const root: TreeNode = {
      label: 'Infra',
      expandedIcon: 'fa-folder-open',
      collapsedIcon: 'fa-folder',
      expanded: true,
      children: [],
    };

    const probeMap: Map<number, InfraHost[]> = new Map();

    const hostMap: Map<number, InfraService[]> = new Map();

    this.loading = true;

    const infraTree =  {
      label: 'Infra',
      expandedIcon: 'fa-folder-open',
      collapsedIcon: 'fa-folder',
      expanded: true,
      children: [],
    };

    for (const infra of this.totalList) {
      const infraType = infra.infraType.name;
      if (infraType === 'HOST') {
        const infraHost: InfraHost = infra;
        if (filterStr && String(infraHost.ip).indexOf(filterStr) < 0) {
          continue;
        }

        if (probeMap.has(infraHost.probe.id) === false) {
          probeMap.set(infraHost.probe.id, []);
        }

        const ihl: InfraHost[] = probeMap.get(infraHost.probe.id);
        ihl.push(infraHost);
        probeMap.set(infraHost.probe.id, ihl);
        // const data: HostData = {
        //   id: String(infra.id),
        //   target: infra.target,
        //   host: infra,
        //   services: new Array(),
        // };
        // this.hostDataList.push(data);
      } else if (infraType === 'OS_SERVICE') {
        const infraService: InfraService = infra;
        if (filterStr && this.checkFilterString(infraService, filterStr)) {
          continue;
        }

        if (hostMap.has(infraService.host.ip) === false) {
          hostMap.set(infraService.host.ip, []);
        }

        const isl = hostMap.get(infraService.host.ip);
        isl.push(infraService);

        // const existHost = this.getExistHost(infraService.host);
        // if (existHost !== null) {
        //   existHost.services.push(infraService);
        // } else {
        //   const host: HostData = {
        //     id: String(infra.id),
        //     target: infra.target,
        //     host: infraService.host,
        //     services: new Array()
        //   };
        //   host.services.push(infraService);
        //   this.hostDataList.push(host);
        // }


        const probeTreeNodes: TreeNode[] = [];

        probeMap.forEach((ifhl: InfraHost[], key: number) => {

          const tp: TreeNode = {
            label: 'Probe - ' + key,
            expandedIcon: 'fa-folder-open',
            collapsedIcon: 'fa-folder',
            expanded: this.DEFAULT_EXPANDED.valueOf(),
            children: [],
          };

          ifhl.map((ih: InfraHost, idx: number) => {

            const th: TreeNode = {
              label: 'Host - ' + ih.ip,
              expandedIcon: 'fa-folder-open',
              collapsedIcon: 'fa-folder',
              expanded: this.DEFAULT_EXPANDED.valueOf(),
              children: [],
            };

            if (hostMap.has(ih.ip)) {

              const ifsl = hostMap.get(ih.ip);

              for (let i = 0 ; i < ifsl.length; ++i) {
                const ts: TreeNode = {
                  label: 'Service - ' + ifsl[i].vendor.name,
                  expandedIcon: 'fa-folder-open',
                  collapsedIcon: 'fa-folder',
                  expanded: this.DEFAULT_EXPANDED.valueOf(),
                  children: [],
                };

                th.children.push(ts);
              }

            }


            tp.children.push(th);

          });

          probeTreeNodes.push(tp);
        });



        infraTree.children.push(probeTreeNodes);


      }


    }
    this.loading = false;


    return infraTree;

  }

  checkFilterString(infraService: InfraService, filterStr: string) {
    const upperCased = filterStr.toUpperCase().toUpperCase();
    if (infraService.vendor.name.toUpperCase().indexOf(upperCased) < 0 &&
      String(infraService.port).toUpperCase().indexOf(upperCased) < 0 &&
      infraService.portType.toUpperCase().indexOf(upperCased)) {
        return true;
    }
    return false;
  }

  getExistHost(infraHost: InfraHost): HostData {
    let node = null;
    for (const data of this.hostDataList) {
      if (data.host.ip === infraHost.ip) {
        node = data;
      }
    }
    return node;
  }

  showDialog() {
    this.display = true;
  }

  closeDialog() {
    this.display = false;
  }

  expandAll() {
    this.infraTree.forEach(node => {
      this.expandRecursive(node, true);
    });
  }

  collapseAll() {
    this.infraTree.forEach(node => {
      this.expandRecursive(node, false);
    });
  }

  private expandRecursive(node: TreeNode, isExpand: boolean) {
    node.expanded = isExpand;
    if (node.children) {
      node.children.forEach(childNode => {
        this.expandRecursive(childNode, isExpand);
      });
    }
  }
}

const testInfraList = [
  {
    label: 'Infra',
    expandedIcon: 'fa-folder-open',
    collapsedIcon: 'fa-folder',
    expanded: true,
    children: [
      {
        label: 'Zone - 192.168.1.0/24',
        expandedIcon: 'fa-folder-open',
        collapsedIcon: 'fa-folder',
        expanded: true,
        children: [
          {
            label: 'Host - 192.168.1.106 - Snoop Host',
            expandedIcon: 'fa-folder-open',
            collapsedIcon: 'fa-folder',
            expanded: true,
            children: [
              {
                label: 'Sensors - WMI, SSH, SNMP',
                expandedIcon: 'fa-folder-open',
                collapsedIcon: 'fa-folder',
                expanded: true
              },
              {
                label: 'Service - FTP(21)',
                expandedIcon: 'fa-folder-open',
                collapsedIcon: 'fa-folder',
                expanded: true,
                children: [
                  {
                    label: 'Sensors - FTP, Sensor',
                    expandedIcon: 'fa-folder-open',
                    collapsedIcon: 'fa-folder',
                    expanded: true
                  }
                ]
              }
            ]
          },
          {
            label: 'Host - 192.168.1.103 - Geek Host',
            expandedIcon: 'fa-folder-open',
            collapsedIcon: 'fa-folder',
            expanded: true,
            children: [
              {
                label: 'Sensors - WMI, SSH, SNMP',
                expandedIcon: 'fa-folder-open',
                collapsedIcon: 'fa-folder',
                expanded: true
              },
              {
                label: 'Service - MySQL(3306)',
                expandedIcon: 'fa-folder-open',
                collapsedIcon: 'fa-folder',
                expanded: true,
                children: [
                  {
                    label: 'Sensors - MySQL, PING',
                    expandedIcon: 'fa-folder-open',
                    collapsedIcon: 'fa-folder',
                    expanded: true
                  }
                ]
              },
              {
                label: 'Service - PostgreSQL(5555)',
                expandedIcon: 'fa-folder-open',
                collapsedIcon: 'fa-folder',
                expanded: true,
                children: [
                  {
                    label: 'Sensors - PostgreSQL, PING',
                    expandedIcon: 'fa-folder-open',
                    collapsedIcon: 'fa-folder',
                    expanded: true
                  }
                ]
              }
            ]
          }
        ]
      },
      {
        label: 'Zone - 192.168.10.0/24',
        expandedIcon: 'fa-folder-open',
        collapsedIcon: 'fa-folder',
        expanded: true,
        children: [
          {
            label: 'Host - 192.168.10.106 - Snoop Host',
            expandedIcon: 'fa-folder-open',
            collapsedIcon: 'fa-folder',
            expanded: true,
            children: [
              {
                label: 'Sensors - WMI, SSH, SNMP',
                expandedIcon: 'fa-folder-open',
                collapsedIcon: 'fa-folder',
                expanded: true
              },
              {
                label: 'Service - FTP(21)',
                expandedIcon: 'fa-folder-open',
                collapsedIcon: 'fa-folder',
                expanded: true,
                children: [
                  {
                    label: 'Sensors - FTP, Sensor',
                    expandedIcon: 'fa-folder-open',
                    collapsedIcon: 'fa-folder',
                    expanded: true
                  }
                ]
              }
            ]
          },
          {
            label: 'Host - 192.168.10.103 - Geek Host',
            expandedIcon: 'fa-folder-open',
            collapsedIcon: 'fa-folder',
            expanded: true,
            children: [
              {
                label: 'Sensors - WMI, SSH, SNMP',
                expandedIcon: 'fa-folder-open',
                collapsedIcon: 'fa-folder',
                expanded: true
              },
              {
                label: 'Service - MySQL(3306)',
                expandedIcon: 'fa-folder-open',
                collapsedIcon: 'fa-folder',
                expanded: true,
                children: [
                  {
                    label: 'Sensors - MySQL, PING',
                    expandedIcon: 'fa-folder-open',
                    collapsedIcon: 'fa-folder',
                    expanded: true
                  }
                ]
              },
              {
                label: 'Service - PostgreSQL(5555)',
                expandedIcon: 'fa-folder-open',
                collapsedIcon: 'fa-folder',
                expanded: true,
                children: [
                  {
                    label: 'Sensors - PostgreSQL, PING',
                    expandedIcon: 'fa-folder-open',
                    collapsedIcon: 'fa-folder',
                    expanded: true
                  }
                ]
              }
            ]
          }
        ]
      }
    ]
  }
];