Administrator / maps-admin

  import {Component, ViewEncapsulation} from '@angular/core';
  import {GridOptions} from 'ag-grid/main';

  
  import { ServiceObjectService } from '../../../services/service-object.service';
  import { ServiceObject } from '../../../models/service-object';
  import { EditorComponent } from '../../../helpers/editor.component';
  import { RendererComponent } from '../../../helpers/renderer.component';
  import { ServiceObjectCreateService } from '../../../services/service-object-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 { DepartmentAffiliationList } from '../../../models/department-affiliation-list';

  import { BooleanSelectList } from '../../../models/boolean-select-list';
  import { SettlementSelectList } from '../../../models/settlement-select-list';

  import { routerTransition } from '../../../animations/router.animation';

  
  // only import this if you are using the ag-Grid-Enterprise
  
  @Component({
      selector: 'service-object',
      templateUrl: 'service-object.component.html',
      styleUrls: ['service-object.scss'],

      encapsulation: ViewEncapsulation.None,

  })

  export class ServiceObjectComponent {

  
      public showGrid: boolean;
      public rowData: any[];
      public rowCount: string;
      public regions: RegionSelectList[];
      public states: StateCommonSelectList[];

      public departmentAffiliation: DepartmentAffiliationList[];

      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: ServiceObjectService,
          private dataService: ServiceObjectCreateService,

          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.departmentAffiliation = models.departmentAffiliationListDsM as DepartmentAffiliationList[];

          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 ServiceObject];
            }
        }).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 ServiceObject());
          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: 'serviceObjectId',

        },
        {
          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,

        },

      ];
    }
  
      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);
      }
  }