src/app/data/bus-stop/bus-stop.component.ts

import { Component, ViewEncapsulation } from '@angular/core';
import { TdLoadingService } from '@covalent/core';
import { GridOptions } from 'ag-grid/main';
import { BusStopService } from '../../../services/bus-stop.service';
import { BusStop } from '../../../models/bus-stop';
import { EditorComponent } from '../../../helpers/editor.component';
import { RendererComponent } from '../../../helpers/renderer.component';
import { BusStopCreateService } from '../../../services/bus-stop-create.service';
import { BooleanSelectListService } from '../../../services/boolean-select-list.service';
import { RegionSelectList } from '../../../models/region-select-list';
import { StateCommonSelectList } from '../../../models/state-common-select-list';
import { RoadSelectList } from '../../../models/road-select-list';
import { BooleanSelectList } from '../../../models/boolean-select-list';
import { SettlementSelectList } from '../../../models/settlement-select-list';
import { SurfaceTypeSelectList } from '../../../models/surface-type-select-list';
import { routerTransition } from '../../../animations/router.animation';
// only import this if you are using the ag-Grid-Enterprise
@Component({
    selector: 'bus-grid',
    templateUrl: 'bus-stop.component.html',
    styleUrls: ['bus-stop.scss'],
    encapsulation: ViewEncapsulation.None,
})
export class BusStopComponent {
    private columnDefs: any[];
    private gridOptions: GridOptions;
    public showGrid: boolean;
    public rowData: any[];
    public rowCount: string;
    public regions: RegionSelectList[];
    public states: StateCommonSelectList[];
    public surfaceTypes: SurfaceTypeSelectList[];
    public settlements: SettlementSelectList[];
    public roads: RoadSelectList[];
    public boolean: BooleanSelectList[];
    public isLoading: boolean = false;
    public isBootstrapping: boolean = true;
    public isSelected: boolean = true;
    constructor(
        protected service: BusStopService,
        private dataService: BusStopCreateService,
        private booleanService: BooleanSelectListService,
        private loadingService: TdLoadingService,
    ) {
        this.gridOptions = <GridOptions>{};
        this.gridOptions.enableSorting = true;
        this.showGrid = true;
        this.gridOptions.rowModelType = 'virtual';
        this.booleanService.getModels().then((models) => this.boolean = models);
        this.dataService.getModels().then(models => {
        this.regions = models.regionSelectListDsM as RegionSelectList[];
        this.states = models.stateCommonSelectListDsM as StateCommonSelectList[];
        this.surfaceTypes = models.surfaceTypeSelectListDsM as SurfaceTypeSelectList[];
        this.settlements = models.settlementSelectListDsM as SettlementSelectList[];
        this.roads = models.roadSelectListDsM as RoadSelectList[];
      }).then(() => {
            this.createColumnDefs();
            this.isBootstrapping = false;
      });
        this.service.getData().then((data) => {
          if (data.length){
            this.rowData = data;
          } else {
            this.rowData = [new BusStop()];
          }
      }).then(() => {
          this.gridOptions.api.setDatasource(this.setRowData(this.rowData));
          this.gridOptions.api.refreshVirtualPageCache();
      });
    }
    setRowData(allOfTheData) {
      let dataSource = {
          rowCount: null, // behave as infinite scroll
          getRows: function (params) {
              console.log('asking for ' + params.startRow + ' to ' + params.endRow);
              // At this point in your code, you would call the server, using $http if in AngularJS.
              // To make the demo look real, wait for 500ms before returning
              // take a slice of the total rows
              let rowsThisPage = allOfTheData.slice(params.startRow, params.endRow);
              // if on or after the last page, work out the last row.
              let lastRow = -1;
              if (allOfTheData.length <= params.endRow) {
                  lastRow = allOfTheData.length;
              }
              // call the success callback
              params.successCallback(rowsThisPage, lastRow);
          }
      };
      return dataSource;
  }
  enableLoader(): void {
      if (!this.isLoading) {
        this.isLoading = true;
        this.loadingService.register('loading');
      }
  }
  disableLoader(): void {
      if (this.isLoading) {
        this.isLoading = false;
        this.loadingService.resolve('loading');
      }
  }
  onDeleteConfirm(event): void {
    if (window.confirm('Вы уверены что хотите удалить??')) {
      event.confirm.resolve();
    } else {
      event.confirm.reject();
    }
  }
  public addNewRow() {
        this.rowData.unshift(new BusStop());
        this.gridOptions.api.setDatasource(this.setRowData(this.rowData));
        this.gridOptions.api.refreshVirtualPageCache();
  }
  private createColumnDefs() {
    this.columnDefs = [
      {
        headerName: '#',
        width: 30,
        checkboxSelection: true,
        suppressSorting: true,
        suppressMenu: true,
        pinned: true
      },
      {
        headerName: 'ID',
        field: 'busStopId',
      },
      {
        headerName: 'Назва дороги',
        field: 'roadId',
        editable: true,
        cellEditorFramework: EditorComponent,
        cellRendererFramework: RendererComponent,
        cellEditorParams: {
          data: this.roads,
          valueCol: 'roadId',
          labelCol: 'name'
        }
      },
      {
        headerName: 'Область',
        field: 'regionId',
        editable: true,
        cellEditorFramework: EditorComponent,
        cellRendererFramework: RendererComponent,
        cellEditorParams: {
          data: this.regions,
          valueCol: 'regionId',
          labelCol: 'name'
        }
      },
      {
        headerName: 'Місцезнаходження, км+ справа',
        field: 'locationRight',
        editable: true,
      },
      {
        headerName: 'Місцезнаходження, км+ зліва',
        field: 'locationLeft',
        editable: true,
      },
      {
        headerName: 'Тип покриття',
        field: 'surfaceTypeId',
        editable: true,
        cellEditorFramework: EditorComponent,
        cellRendererFramework: RendererComponent,
        cellEditorParams: {
          data: this.surfaceTypes,
          valueCol: 'surfaceTypeId',
          labelCol: 'name'
        }
      },
      {
        headerName: 'Технічний стан',
        field: 'stateCommonId',
        editable: true,
        cellEditorFramework: EditorComponent,
        cellRendererFramework: RendererComponent,
        cellEditorParams: {
          data: this.states,
          valueCol: 'stateCommonId',
          labelCol: 'value'
        }
      },
      ,
      {
        headerName: 'Наявність елементів зупин. майдан',
        field: 'areaStopAvailability',
        editable: true,
        cellEditorFramework: EditorComponent,
        cellRendererFramework: RendererComponent,
        cellEditorParams: {
          data: this.boolean,
          valueCol: 'value',
          labelCol: 'label'
        }
      },
      {
        headerName: 'Наявність елементів посад. майдан',
        field: 'areaLandAvailability',
        editable: true,
        cellEditorFramework: EditorComponent,
        cellRendererFramework: RendererComponent,
        cellEditorParams: {
          data: this.boolean,
          valueCol: 'value',
          labelCol: 'label'
        }
      },
      {
        headerName: 'Наявність елементів заїзна кишеня',
        field: 'pocketAvailability',
        editable: true,
        cellEditorFramework: EditorComponent,
        cellRendererFramework: RendererComponent,
        cellEditorParams: {
          data: this.boolean,
          valueCol: 'value',
          labelCol: 'label'
        }
      },
      {
        headerName: 'Наявність туалету',
        field: 'toiletAvailability',
        editable: true,
        cellEditorFramework: EditorComponent,
        cellRendererFramework: RendererComponent,
        cellEditorParams: {
          data: this.boolean,
          valueCol: 'value',
          labelCol: 'label'
        }
      },
      {
        headerName: 'Рік будівництва',
        field: 'yearBuild',
        editable: true,
      },
      {
        headerName: 'Рік ремонту',
        field: 'yearRepair',
        editable: true,
      }
    ];
  }
    private onCellClicked($event) {
        console.log('onCellClicked: ' + $event.rowIndex + ' ' + $event.colDef.field);
    }
    private onCellValueChanged($event) {
        if ($event.oldValue !== $event.newValue) {
            let data = JSON.stringify($event.data);
            let id = $event.data.busStopId;
            let result = null;
            if (id) {
                this.enableLoader();
                result = this.service.update(id, data).then(() => this.disableLoader());
            } else {
                // Protection of posting new row being already sent.
                if (this.isLoading) {
                    return ;
                }
                this.enableLoader();
                result = this.service.create(data).then((busStop) => {
                    this.rowData[$event.node.rowIndex] = busStop;
                    this.gridOptions.api.setDatasource(this.setRowData(this.rowData));
                    this.gridOptions.api.refreshVirtualPageCache();
                    this.disableLoader();
                });
            }
        }
    }
    private deleteRows() {
        let rows = this.gridOptions.api.getSelectedNodes();
        if (!rows.length) {
            return ;
        }
        rows.forEach(element => {
            let id = element.data.busStopId;
            if (id) {
                this.enableLoader();
                this.service.delete(id).then(() => this.disableLoader());
            }
        });
        // Sort in order to protect array from reindexing (remove rear elements first)
        let sorted = rows.sort((a, b) => {
                if (a > b) {
                    return -1;
                } else {
                    return 1;
                }
            });
        sorted.forEach(item => {
            this.rowData.splice(item.rowIndex, 1);
        });
        this.gridOptions.api.setDatasource(this.setRowData(this.rowData));
        this.gridOptions.api.refreshVirtualPageCache();
    }
    private onCellDoubleClicked($event) {
        console.log('onCellDoubleClicked: ' + $event.rowIndex + ' ' + $event.colDef.field);
    }
    private onCellContextMenu($event) {
        console.log('onCellContextMenu: ' + $event.rowIndex + ' ' + $event.colDef.field);
    }
    private onCellFocused($event) {
        console.log('onCellFocused: (' + $event.rowIndex + ',' + $event.colIndex + ')');
    }
    private onRowSelected($event) {
        // taking out, as when we 'select all', it prints to much to the console!!
        // console.log('onRowSelected: ' + $event.node.data.name);
    }
    private onSelectionChanged() {
        console.log('selectionChanged');
    }
    private onBeforeFilterChanged() {
        console.log('beforeFilterChanged');
    }
    private onAfterFilterChanged() {
        console.log('afterFilterChanged');
    }
    private onFilterModified() {
        console.log('onFilterModified');
    }
    private onBeforeSortChanged() {
        console.log('onBeforeSortChanged');
    }
    private onAfterSortChanged() {
        console.log('onAfterSortChanged');
    }
    private onVirtualRowRemoved($event) {
        // because this event gets fired LOTS of times, we don't print it to the
        // console. if you want to see it, just uncomment out this line
        // console.log('onVirtualRowRemoved: ' + $event.rowIndex);
    }
    private onRowClicked($event) {
        console.log('onRowClicked: ' + $event.node.data.name);
    }
    public onQuickFilterChanged($event) {
        this.gridOptions.api.setQuickFilter($event.target.value);
    }
    // here we use one generic event to handle all the column type events.
    // the method just prints the event name
    private onColumnEvent($event) {
        console.log('onColumnEvent: ' + $event);
    }
}