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

import { AfterViewInit, Component, Input, OnInit, ViewChild, ViewEncapsulation } from '@angular/core';
import { MatPaginator, MatSort, MatSnackBar } from "@angular/material";
import { Router, ActivatedRoute, Params } from "@angular/router";
import { TranslateService } from "@ngx-translate/core";
import { DataSource } from "@angular/cdk/table";
import { Observable } from "rxjs/Observable";
import { JsonSerializer } from "../../utilities/JsonSerializer";
import { FormGroup } from "@angular/forms";
import { SnackBarNotificationComponent } from "../../shared/components/notificaiton/snack-bar-notification.component";
import { BaseErrorModel } from "../../models/error/BaseErrorModel";
import { DatasetService } from "../../services/dataset/dataset.service";
import { DatasetModel } from "../../models/datasets/DatasetModel";
import { ExternalSourcesService } from "../../services/external-sources/external-sources.service";
import { ExternalSourcesItemModel } from "../../models/external-sources/ExternalSourcesItemModel";



@Component({
  selector: 'app-dataset-editor-component',
  templateUrl: 'dataset-editor.component.html',
  styleUrls: ['./dataset-editor.component.css'],
  providers: [DatasetService, ExternalSourcesService],
  encapsulation: ViewEncapsulation.None
})
export class DatasetEditorComponent implements AfterViewInit {

  isNew = true;
  dataset: DatasetModel;
  @Input() formGroup: FormGroup = null;

  filtereddataRepositoriesAsync: boolean = false;
  filteredRegistriesAsync: boolean = false;
  filteredServicesAsync: boolean = false;
  
  filtereddataRepositories: ExternalSourcesItemModel[];
  filteredRegistries: ExternalSourcesItemModel[];
  filteredServices: ExternalSourcesItemModel[];
  
  constructor(
    private datasetService: DatasetService,
    private externalSourcesService: ExternalSourcesService,
    private route: ActivatedRoute,
    public snackBar: MatSnackBar,
    public router: Router,
    public language: TranslateService,
  ) {

  }

  ngAfterViewInit() {
    /* this.route.params.subscribe((params: Params) => {
      const itemId = params['id'];

      if (itemId != null) {
        this.isNew = false;
        this.datasetService.getSingle(itemId).map(data => data as DatasetModel)
          .subscribe(data => {
            this.dataset = new JsonSerializer<DatasetModel>().fromJSONObject(data, DatasetModel);
            this.formGroup = this.dataset.buildForm();
          });
      } else {
        this.dataset = new DatasetModel();
        setTimeout(() => {
          this.formGroup = this.dataset.buildForm();
        });
      }
    }); */
  }

  formSubmit(): void {
    //this.touchAllFormFields(this.formGroup);
    if (!this.isFormValid()) { return; }
    //this.onSubmit();
  }

  public isFormValid() {
    return this.formGroup.valid;
  }

  onSubmit(): void {
    this.datasetService.createDataset(this.formGroup.value).subscribe(
      complete => this.onCallbackSuccess(),
      error => this.onCallbackError(error)
    );
  }

  onCallbackSuccess(): void {
    this.snackBar.openFromComponent(SnackBarNotificationComponent, {
      data: { message: this.isNew ? 'GENERAL.SNACK-BAR.SUCCESSFUL-CREATION' : 'GENERAL.SNACK-BAR.SUCCESSFUL-UPDATE', language: this.language },
      duration: 3000,
      extraClasses: ['snackbar-success']
    })
    this.router.navigate(['/datasets']);
  }

  onCallbackError(error: any) {
    this.setErrorModel(error.error);
    //this.validateAllFormFields(this.formGroup);
  }

  public setErrorModel(errorModel: BaseErrorModel) {
    Object.keys(errorModel).forEach(item => {
      (<any>this.dataset.errorModel)[item] = (<any>errorModel)[item];
    })
  }

  public cancel(): void {
    this.router.navigate(['/datasets']);
  }

  filterdataRepositories(value: string): void {
    
    this.filtereddataRepositories = undefined;
    if (value) {
      this.filtereddataRepositoriesAsync = true;
      
      this.externalSourcesService.searchDMPOrganizations(value).subscribe(items => {
        this.filtereddataRepositories = items;
        this.filtereddataRepositoriesAsync = false;

        // this.filteredOrganisations = items.filter((filteredObj: any) => {
        //   return this.objectsModel ? this.objectsModel.indexOf(filteredObj) < 0 : true;
        // });

      });
    }
  }

  filterRegistries(value: string): void {
    
    this.filteredRegistries = undefined;
    if (value) {
      this.filteredRegistriesAsync = true;
      
      this.externalSourcesService.searchDMPResearchers(value).subscribe(items => {
        this.filteredRegistries = items;
        this.filteredRegistriesAsync = false;

        // this.filteredOrganisations = items.filter((filteredObj: any) => {
        //   return this.objectsModel ? this.objectsModel.indexOf(filteredObj) < 0 : true;
        // });

      });
    }
  }

  filterServices(value: string): void {
    
    this.filteredServices = undefined;
    if (value) {
      this.filteredServicesAsync = true;
      
      this.externalSourcesService.searchDMPResearchers(value).subscribe(items => {
        this.filteredServices = items;
        this.filteredServicesAsync = false;

        // this.filteredOrganisations = items.filter((filteredObj: any) => {
        //   return this.objectsModel ? this.objectsModel.indexOf(filteredObj) < 0 : true;
        // });

      });
    }
  }
}