src/app/components/grid/rich-grid.component.ts

import {Component, ViewEncapsulation} from "@angular/core";
import {GridOptions} from "ag-grid/main";
import ProficiencyFilter from "./proficiencyFilter";
import SkillFilter from "./skillFilter";
import RefData from "./refData";
import { BusStopService } from './busStop.service';
import { busStop } from './busStop';
import { EditorComponent } from '../../helpers/editor.component';
import { RendererComponent } from '../../helpers/renderer.component';
import { BusStopCreateService } from '../../services/busstopcreate.service';
import { BooleanSelectListService } from '../../services/booleanselectlist.service';
import { RegionSelectList } from '../../models/regionselectlist';
import { StateCommonSelectList } from '../../models/statecommonselectlist';
import { RoadSelectList } from '../../models/roadselectlist';
import { BooleanSelectList } from '../../models/booleanselectlist';
import { SettlementSelectList } from '../../models/settlementselectlist';
import { SurfaceTypeSelectList } from '../../models/surfacetypeselectlist';
// only import this if you are using the ag-Grid-Enterprise
@Component({
    selector: 'rich-grid',
    templateUrl: 'rich-grid.component.html',
    styleUrls: ['rich-grid.css', 'proficiency-renderer.css'],
    encapsulation: ViewEncapsulation.None
})
export class RichGridComponent {
    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;
    private columnDefs: any[];
    private gridOptions: GridOptions;
    constructor(
        protected service: BusStopService,
        private dataService: BusStopCreateService,
        private booleanService: BooleanSelectListService
    ) {
        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;
  }
  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: 'stateCommonId',
        editable: true,
        cellEditorFramework: EditorComponent,
        cellRendererFramework: RendererComponent,
        cellEditorParams: {
          data: this.states,
          valueCol: 'stateCommonId',
          labelCol: 'value'
        }
      },
      {
        headerName: 'Наявність туалету',
        field: 'toiletAvailability',
        editable: true,
        cellEditorFramework: EditorComponent,
        cellRendererFramework: RendererComponent,
        cellEditorParams: {
          data: this.boolean,
          valueCol: 'value',
          labelCol: 'label'
        }
      }
    ];
  }
    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.isLoading = true;
                result = this.service.update(id, data).then(() => this.isLoading = false);
            } else {
                // Protection of posting new row being already sent.
                if (this.isLoading) {
                    return ;
                }
                this.isLoading = true;
                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.isLoading = false;
                });
            }
        }
    }
    private deleteRows() {
        let rows = this.gridOptions.api.getSelectedNodes();
        if (!rows.length) {
            return ;
        }
        rows.forEach(element => {
            let id = element.data.busStopId;
            if (id) {
                this.isLoading = true;
                this.service.delete(id).then(() => this.isLoading = false);
            }
        });
        // 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);
    }
}