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

import { BaseErrorModel } from '../../models/error/BaseErrorModel';
import { SnackBarNotificationComponent } from '../../shared/components/notificaiton/snack-bar-notification.component';
import { DatasetProfileCriteria } from '../../models/criteria/dataset-profile/DatasetProfileCriteria';
import { DataManagementPlanModel } from '../../models/data-managemnt-plans/DataManagementPlanModel';
import { JsonSerializer } from '../../utilities/JsonSerializer';
import { DataManagementPlanCriteria } from '../../models/criteria/data-management-plan/DataManagementPlanCriteria';
import { RequestItem } from '../../models/criteria/RequestItem';
import { DatasetService } from '../../services/dataset/dataset.service';
import { ExternalSourcesItemModel } from '../../models/external-sources/ExternalSourcesItemModel';
import { DatasetProfileModel } from '../../models/datasetprofile/DatasetProfileModel';
import { DatasetProfileDefinitionModel } from '../../models/DatasetProfileDefinitionModel';
import { DatasetWizardModel } from '../../models/datasets/DatasetWizardModel';
import { DataManagementPlanService } from '../../services/data-management-plan/data-management-plan.service';
import { ExternalSourcesService } from '../../services/external-sources/external-sources.service';
import { DatasetWizardService } from '../../services/dataset-wizard/dataset-wizard.service';
import { TranslateService } from '@ngx-translate/core';
import { ActivatedRoute, Router, Params } from '@angular/router';
import { Component, ViewChild, OnInit, AfterViewInit, ViewEncapsulation } from "@angular/core";
import { FormGroup, Validators, FormBuilder } from "@angular/forms";
import * as FileSaver from 'file-saver';
import { MatPaginator, MatSort, MatSnackBar, MatStepper } from "@angular/material";

@Component({
  selector: 'app-dataset-wizard-component',
  templateUrl: 'dataset-wizard.component.html',
  styleUrls: ['./dataset-wizard.component.scss'],
  providers: [DatasetWizardService, ExternalSourcesService, DataManagementPlanService],
  encapsulation: ViewEncapsulation.None
})
export class DatasetWizardComponent {
  @ViewChild('stepper') stepper: MatStepper;

  //dmpAutoCompleteConfiguration: AutoCompleteConfiguration;
  //datasetProfileAutoCompleteConfiguration: AutoCompleteConfiguration;
  datasetWizardModel: DatasetWizardModel;
  isNew = true;
  formGroup: FormGroup;
  datasetProfileDefinitionModel: DatasetProfileDefinitionModel;

  availableProfiles: DatasetProfileModel[] = [];

  filtereddataRepositoriesAsync: boolean = false;
  filteredRegistriesAsync: boolean = false;
  filteredServicesAsync: boolean = false;
  filteredExternalDatasetsAsync: boolean = false;

  filtereddataRepositories: ExternalSourcesItemModel[];
  filteredRegistries: ExternalSourcesItemModel[];
  filteredServices: ExternalSourcesItemModel[];
  filteredExternalDatasets: ExternalSourcesItemModel[];
  itemId: string
  constructor(
    private datasetWizardService: DatasetWizardService,
    private formBuilder: FormBuilder,
    private datasetService: DatasetService,
    private route: ActivatedRoute,
    public snackBar: MatSnackBar,
    public router: Router,
    public language: TranslateService,
    public externalSourcesService: ExternalSourcesService,
    public dataManagementPlanService: DataManagementPlanService
  ) {

  }

  isLinear = false;
  firstStepFormGroup: FormGroup;
  secondFormGroup: FormGroup;

  ngOnInit() {
    let dmpRequestItem: RequestItem<DataManagementPlanCriteria> = new RequestItem();
    dmpRequestItem.criteria = new DataManagementPlanCriteria();


    this.route.params.subscribe((params: Params) => {
      this.itemId = params['id'];
      const dmpId = params['dmpId'];
      if (this.itemId != null) {
        this.isNew = false;
        this.datasetWizardService.getSingle(this.itemId).map(data => data as DatasetWizardModel)
          .subscribe(data => {
            this.datasetWizardModel = JsonSerializer.fromJSONObject(data, DatasetWizardModel);
            this.formGroup = this.datasetWizardModel.buildForm();
            this.loadDatasetProfiles();
          });
      } else if (dmpId != null) {
        this.isNew = true;
        this.dataManagementPlanService.getSingle(dmpId).map(data => data as DataManagementPlanModel)
          .subscribe(data => {
            this.datasetWizardModel = new DatasetWizardModel();
            setTimeout(() => {
              this.datasetWizardModel.dmp = data;
              this.formGroup = this.datasetWizardModel.buildForm();
              this.loadDatasetProfiles();
            });
          });
      } else {

      }
    });


  }

  ngAfterViewInit() {
    this.route.params.subscribe((params: Params) => {
      let itemId = params['id'];
      if (itemId != null) this.stepper.selectedIndex = 2;
    })
  }


  loadDatasetProfiles() {
    let datasetProfileRequestItem: RequestItem<DatasetProfileCriteria> = new RequestItem();
    datasetProfileRequestItem.criteria = new DatasetProfileCriteria();
    datasetProfileRequestItem.criteria.id = this.datasetWizardModel.dmp.id;
    this.datasetWizardService.getAvailableProfiles(datasetProfileRequestItem).subscribe(items => {
      this.availableProfiles = JsonSerializer.fromJSONArray(items, DatasetProfileModel);
    });
  }

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

  getDefinition() {
    if (this.isNew) {
      this.datasetWizardService.getDefinition(this.formGroup.get("profile").get("id").value).subscribe(item => {
        this.datasetWizardModel.datasetProfileDefinition = JsonSerializer.fromJSONObject(item, DatasetProfileDefinitionModel);
        this.datasetProfileDefinitionModel = this.datasetWizardModel.datasetProfileDefinition;
        this.formGroup.addControl("datasetProfileDefinition", this.datasetProfileDefinitionModel.buildForm())
      })
    }
  }


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

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

  onSubmit(): void {
    this.datasetWizardService.createDataset(this.formGroup.value).subscribe(
      complete => {
        this.datasetWizardService.getSingle(complete.id).subscribe(
          result => {
            this.datasetWizardModel = JsonSerializer.fromJSONObject(result, DatasetWizardModel);
          }
        )
        this.onCallbackSuccess()
      },
      error => this.onCallbackError(error)
    );
  }

  submit() {
    this.datasetWizardService.createDataset(this.formGroup.value).subscribe(data => {
      this.router.navigateByUrl("/datasets/dmp/" + this.datasetWizardModel.dmp.id);
    });
  }


  save() {
    this.formGroup.get("status").setValue("0");
    this.submit();
  }

  saveFinalize() {
    this.formGroup.get("status").setValue("1");
    this.submit();
  }

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

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

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

  filterdataRepositories(value: string): void {

    this.filtereddataRepositories = undefined;
    if (value) {
      this.filtereddataRepositoriesAsync = true;

      this.externalSourcesService.searchDatasetRepository(value).subscribe(items => {
        this.filtereddataRepositories = items;
        this.filtereddataRepositoriesAsync = false;
      });
    }
  }

  filterRegistries(value: string): void {

    this.filteredRegistries = undefined;
    if (value) {
      this.filteredRegistriesAsync = true;

      this.externalSourcesService.searchDatasetRegistry(value).subscribe(items => {
        this.filteredRegistries = items;
        this.filteredRegistriesAsync = false;

      });
    }
  }

  filterServices(value: string): void {

    this.filteredServices = undefined;
    if (value) {
      this.filteredServicesAsync = true;

      this.externalSourcesService.searchDatasetService(value).subscribe(items => {
        this.filteredServices = items;
        this.filteredServicesAsync = false;
      });
    }
  }


  filterExternalDatasets(value: string): void {

    this.filteredExternalDatasets = undefined;
    if (value) {
      this.filteredExternalDatasetsAsync = true;

      this.externalSourcesService.searchDatasetSExternalDatasetservice(value).subscribe(items => {
        this.filteredExternalDatasets = items;
        this.filteredExternalDatasetsAsync = false;
      });
    }
  }

  downloadPDF(): void {
    this.datasetWizardService.downloadPDF(this.itemId).subscribe(response => {
      const blob = new Blob([response.body], { type: 'application/pdf' })
      const filename = this.getFilenameFromContentDispositionHeader(response.headers.get('Content-Disposition'));

      FileSaver.saveAs(blob, filename)
    })
  }

  getFilenameFromContentDispositionHeader(header: string): string { // expecting filename=XXXX or filename="XXXX" to exist
    // const regex: RegExp = new RegExp(/filename=((\"(.*)\")|([^;]*))/g);
    const regex: RegExp = new RegExp(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/g);

    const matches = header.match(regex);
    let filename: string;
    for (let i = 0; i < matches.length; i++) {
      const match = matches[i];
      if (match.includes('filename="')) {
        filename = match.substring(10, match.length - 1);
        break;
      } else if (match.includes('filename=')) {
        filename = match.substring(9);
        break;
      }
    }
    return filename;
  }
}