argos/dmp-frontend/src/app/datasets/listing/dataset-listing.component.ts

import { Field } from '../../models/Field';
import { DataTableRequest } from '../../models/data-table/DataTableRequest';
import { DatasetListingModel } from '../../models/datasets/DatasetListingModel';
import { DatasetCriteria } from '../../models/criteria/dataset/DatasetCriteria';
import { DatasetService } from '../../services/dataset/dataset.service';
import { Component, ViewChild, OnInit, AfterViewInit } from "@angular/core";
import { MatPaginator, MatSort, MatSnackBar } from "@angular/material";
import { Router, Params, ActivatedRoute } from "@angular/router";
import { TranslateService } from "@ngx-translate/core";
import { DataSource } from "@angular/cdk/table";

import { Observable } from "rxjs/Observable";
import { PageEvent } from '@angular/material';
import { DataManagementPlanService } from "../../services/data-management-plan/data-management-plan.service";
import { DataManagementPlanModel } from "../../models/data-managemnt-plans/DataManagementPlanModel";
import { DatasetCriteriaComponent } from '../../shared/components/criteria/datasets/datasets-criteria.component';
import { BreadcrumbItem } from '../../shared/components/breadcrumb/definition/breadcrumb-item';
import { IBreadCrumbComponent } from '../../shared/components/breadcrumb/definition/IBreadCrumbComponent';
import { Utilities } from '../../utilities/utilities';
import { JsonSerializer } from '../../utilities/JsonSerializer';


@Component({
  selector: 'app-dataset-listing-component',
  templateUrl: 'dataset-listing.component.html',
  styleUrls: ['./dataset-listing.component.scss'],
  providers:[Utilities]
})
export class DatasetListingComponent implements OnInit, IBreadCrumbComponent {

  @ViewChild(MatPaginator) _paginator: MatPaginator;
  @ViewChild(MatSort) sort: MatSort;
  @ViewChild(DatasetCriteriaComponent) criteria: DatasetCriteriaComponent;

  breadCrumbs: Observable<BreadcrumbItem[]>;

  dataSource: DatasetDataSource | null;
  displayedColumns: String[] = ['label', 'dmp', 'profile', 'status', 'description', 'created', 'actions'];
  pageEvent: PageEvent;
  titlePrefix: String;
  dmpId: string;

  statuses = [
    { value: '0', viewValue: 'Active' },
    { value: '1', viewValue: 'Inactive' }
  ];

  constructor(
    private datasetService: DatasetService,
    private router: Router,
    private languageService: TranslateService,
    public snackBar: MatSnackBar,
    public route: ActivatedRoute,
    public dataManagementPlanService: DataManagementPlanService,
    public utilities: Utilities
  ) {

  }


  ngOnInit() {

    this.route.params.subscribe(async (params: Params) => {
      this.dmpId = params['dmpId'];
      this.criteria.setCriteria(this.getDefaultCriteria(this.dmpId));
      this.refresh();
      this.criteria.setRefreshCallback(() => this.refresh());
      if (this.dmpId != null) {
        let dmp = await this.dataManagementPlanService.getSingle(this.dmpId).toPromise()
        this.breadCrumbs = Observable.of([{ parentComponentName: "DataManagementPlanEditorComponent", label: dmp.label, url: "dmps/edit/" + this.dmpId }])
        if (params['dmpLabel'] != undefined)
          this.titlePrefix = "for " + params['dmpLabel'];
      } else {
        this.breadCrumbs = Observable.of([])
      }
    });
  }

  refresh() {
    this.dataSource = new DatasetDataSource(this.datasetService, this._paginator, this.sort, this.languageService, this.snackBar, this.criteria, this.dmpId);
  }

  rowClick(rowId: String) {
    this.router.navigate(['/datasets/edit/' + rowId]);
  }

  getDefaultCriteria(dmpId: String): DatasetCriteria {
    const defaultCriteria = new DatasetCriteria();
    if (dmpId != null) {
      defaultCriteria.dmpIds.push(dmpId);
    }
    return defaultCriteria;
  }

  makeItPublic(id: String) {
    this.datasetService.makeDatasetPublic(id).subscribe();
  }

}

export class DatasetDataSource extends DataSource<DatasetListingModel> {

  totalCount = 0;
  isLoadingResults = false;
  constructor(
    private _service: DatasetService,
    private _paginator: MatPaginator,
    private _sort: MatSort,
    private _languageService: TranslateService,
    private _snackBar: MatSnackBar,
    private _criteria: DatasetCriteriaComponent,
    private dmpId: String
  ) {
    super();

  }

  connect(): Observable<DatasetListingModel[]> {
    const displayDataChanges = [
      this._paginator.page
      //this._sort.matSortChange
    ];


    return Observable.merge(...displayDataChanges)
      .startWith(null)
      .switchMap(() => {
        setTimeout(() => {
          this.isLoadingResults = true;
        });
        const startIndex = this._paginator.pageIndex * this._paginator.pageSize;
        let fields: Array<string> = new Array()
        if (this._sort.active) fields = this._sort.direction === "asc" ? ["+" + this._sort.active] : ["-" + this._sort.active];
        const request = new DataTableRequest<DatasetCriteria>(startIndex, this._paginator.pageSize, { fields: fields });
        request.criteria = this._criteria.criteria;
        if (this.dmpId) request.criteria.allVersions = true;
        return this._service.getPaged(request);
      })
      /*.catch((error: any) => {
        this._snackBar.openFromComponent(SnackBarNotificationComponent, {
          data: { message: 'GENERAL.SNACK-BAR.FORMS-BAD-REQUEST', language: this._languageService },
          duration: 3000,
          extraClasses: ['snackbar-warning']
        });
        //this._criteria.criteria.onCallbackError(error);
        return Observable.of(null);
      })*/
      .map(result => {
        result.data = JsonSerializer.fromJSONArray(result.data, DatasetListingModel)
        return result;
      })
      .map(result => {
        setTimeout(() => {
          this.isLoadingResults = false;
        });
        return result;
      })
      .map(result => {
        if (!result) { return []; }
        if (this._paginator.pageIndex === 0) { this.totalCount = result.totalCount; }
        return result.data;
      });
  }

  disconnect() {
    // No-op
  }
}