Untitled

import { Component, OnDestroy, OnInit } from '@angular/core';
import { StoreService } from '@core/services/store.service';
import { Subject, takeUntil } from 'rxjs';
import { ResultSitesDto } from '@shared/models/sites.dtos';
import { SiteService } from '@features/management/service/sites.service';
import { VulnerabilityService } from '@features/vulnerabilities/service/vulnerabilities.service';
import { NotificationService } from '@shared/service/notification.service';
import { VulnerabilitiesModalComponent } from '@features/vulnerabilities/components/dialogs/vulnerabilities-modal/vulnerabilities-modal.component';
import { MatDialog } from '@angular/material/dialog';
import { TranslateService } from '@ngx-translate/core';
import { MapMarkerBySiteIdService } from '@features/vulnerabilities/service/mapMarkerBySiteId.service';
import { MapService } from '@shared/service/maps.service';
import { Vulnerabilities } from '@features/vulnerabilities/service/interface/vulnerabilities.interface';

@Component({
  selector: 'st-vulnerabilities',
  templateUrl: './vulnerabilities.component.html',
  styleUrls: ['./vulnerabilities.component.scss'],
})
export class VulnerabilitiesComponent implements OnInit, OnDestroy {
  loader: boolean = false;

  dataSites: ResultSitesDto[];
  dataCards: Vulnerabilities[] = [];

  filter: any = {
    page: 1,
    size: 10,
    search: [],
    sort: { criteria: '', order: '' },
  };

  dataSite: any;
  totalPage: any;
  dataFilter: any = {
    page: 1,
    size: 10,
    search: [],
    sort: { criteria: '', order: '' },
  };
  initFilter: any = [];
  noResults: boolean = false;

  dataMarker: any;
  dataMarkerInit: any;

  filterMarker: any = {
    page: 1,
    size: 10,
    search: [
      {
        criteria: 'operation',
        word: 'SITE',
        operator: 'eq',
      },
    ],
    sort: { criteria: '', order: '' },
  };

  private readonly _unsubscribe$: Subject<any> = new Subject<any>();

  constructor(
    private readonly storeService: StoreService,
    private readonly matDialog: MatDialog,
    private notification: NotificationService,
    private translate: TranslateService,
    private _vulnerabilityService: VulnerabilityService,
    private _sitesService: SiteService,
    private _mapMarkerBySiteIdService: MapMarkerBySiteIdService,
    private _mapService: MapService
  ) {}

  ngOnInit(): void {
    this.dataSite = [];
    this.serviceAllSite();
    this._mapService.setMarkerMannualy(this.dataMarkerInit);
    this.storeService.setGlobalFilterPeriodVulne(true);
    this.serviceAllDataCards(this.filter);

    this.storeService.globalFilterPeriodVulne$
      .pipe(takeUntil(this._unsubscribe$))
      .subscribe((filter) => {
        this.dataCards = [];
        if (filter) {
          if (typeof filter != 'boolean') {
            this.dataFilter = filter;
            this.serviceAllDataCards(filter);
          }
        } else {
          this.dataFilter = this.filter;
          const cleanSearch = { ...this.filter, search: [] };

          this.serviceAllDataCards(cleanSearch);
        }

        this.filter.page = 1;
      });
  }

  serviceAllSite() {
    this.dataSites = [];
    this._sitesService.findAllSites().subscribe(
      (data) => {
        this.dataSites = data;
      },
      (err) => {
        this.dataSites = [
          {
            id: 0,
            name: this.translate.instant('common.commonMessages.noResults'),
            description: this.translate.instant(
              'common.commonMessages.noResults'
            ),
            colorRgb: 'string',
            ctrCreDt: null,
            ctrUpDt: null,
            ctrUserId: null,
            status: false,
            elasticIndex: null,
          },
        ];
      }
    );
  }

  serviceAllDataCards(params: any) {
    this.loader = true;
    this.dataCards = [];
    this._vulnerabilityService.getDataCards(params).subscribe(
      (resp) => {
        if (resp != null && resp.result.content.length > 0) {
          this.loader = false;
          this.dataCards = resp.result.content;
          this.totalPage = resp.result.totalPages;
          this.noResults = false;
        } else {
          this.dataCards = [];
          this.noResults = true;
          this.loader = false;
        }
      },
      (error) => {
        this.loader = false;
        this.noResults = true;
        this.notification.error(
          this.translate.instant('common.commonMessages.error')
        );
      }
    );
  }

  showModal(data: any) {
    const dialogRef = this.matDialog.open(VulnerabilitiesModalComponent, {
      panelClass: 'container-custom-dialog',
      width: '700px',
      data: {
        data: data,
      },
    });

    dialogRef.afterClosed().subscribe(() => {});
  }

  pageChanges(event: number) {
    if (this.initFilter?.search?.length > 0) {
      this.filter.page = this.dataFilter.page = event;
      this.filter.search = this.initFilter.search;
      this.serviceAllDataCards(this.filter);
    } else {
      // this.filter.page = this.dataFilter.page = event;
      this.filter = { ...this.dataFilter, page: event };
      this.serviceAllDataCards(this.filter);
    }
  }

  selectRangeItems(value: any) {
    this.dataFilter.page = this.filter.page = value.page;
    this.dataFilter.size = this.filter.size = value.size;
    const filter = {
      ...this.initFilter,
      page: this.filter.page,
      size: this.filter.size,
    };
    this.serviceAllDataCards(filter);
  }

  sendDataSite(site: any) {
    this.initFilter = [];
    this.filter.page = 1;
    const dataSite = this.dataSites.find((x) => {
      if (x.id == site.value) {
        return x;
      }
    });
    this.addMarker(dataSite, 'event');
    this.initFilter = {
      ...this.filter,
      page: 1,
      search: [
        {
          criteria: 'device.site._id',
          word: dataSite?.id.toString(),
          operator: 'eq',
        },
      ],
    };
    this.serviceAllDataCards(this.initFilter);
  }

  addMarker(dataSite: any, type: string) {
    if (type === 'init') {
      this._mapMarkerBySiteIdService.getDataMarker(this.filter).subscribe(
        (res) => {
          if (res.result.totalElements > 0) {
            this.dataMarker = res.result.content;
          } else {
            this.dataMarker = [];
            this.notification.warning(
              this.translate.instant('markers.coordinatesEmpty')
            );
          }
        },
        (err) => {
          this.notification.error(err.error.message);
        }
      );
    } else {
      this._vulnerabilityService.sendSiteName(dataSite);
      this._mapMarkerBySiteIdService.getDataMarker(this.filterMarker).subscribe(
        (res) => {
          if (res.result.totalElements > 0) {
            this.dataMarker = {
              lat: res.result.content[0].latitude,
              lng: res.result.content[0].longitude,
              icon: res.result.content[0].icon,
              siteName: dataSite.name,
              colorRgb: dataSite.colorRgb,
            };
            this._mapService.setMarkerMannualy(this.dataMarker);
          } else {
            this.dataMarker = [];
            this.notification.warning(
              this.translate.instant('markers.coordinatesEmpty')
            );
          }
        },
        (err) => {
          this.notification.error(err.error.message);
        }
      );
    }
  }

  ngOnDestroy(): void {
    //@ts-ignore
    this._unsubscribe$.next();
    this._unsubscribe$.complete();
    this.storeService.setGlobalFilterPeriodVulne(false);
  }
}