argos/dmp-frontend/src/app/dmps/wizard/editor/dmp-wizard-editor.component.ts

import { DatasetProfileModel } from '../../../models/datasets/DatasetProfileModel';
import { DatasetProfileCriteria } from '../../../models/criteria/dataset/DatasetProfileCriteria';
import { BaseErrorModel } from '../../../models/error/BaseErrorModel';
import { SnackBarNotificationComponent } from '../../../shared/components/notificaiton/snack-bar-notification.component';
import { JsonSerializer } from '../../../utilities/JsonSerializer';
import { RequestItem } from '../../../models/criteria/RequestItem';
import { ProjectCriteria } from '../../../models/criteria/project/ProjectCriteria';
import { DmpUsersModel } from '../../../models/dmpUsers/DmpUsersModel';
import { ExternalSourcesItemModel } from '../../../models/external-sources/ExternalSourcesItemModel';
import { DataManagementPlanModel } from '../../../models/data-managemnt-plans/DataManagementPlanModel';
import { ProjectService } from '../../../services/project/project.service';
import { ExternalSourcesService } from '../../../services/external-sources/external-sources.service';
import { DataManagementPlanService } from '../../../services/data-management-plan/data-management-plan.service';
import { Component, ViewChild, OnInit, AfterViewInit, ViewEncapsulation, Input } 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 { FormGroup } from '@angular/forms';
import { BaseCriteria } from '../../../models/criteria/BaseCriteria';
import { SingleAutoCompleteConfiguration } from '../../../shared/components/autocompletes/single/single-auto-complete-configuration';
import { LanguageResolverService } from '../../../services/language-resolver/language-resolver.service';
import { MultipleAutoCompleteConfiguration } from '../../../shared/components/autocompletes/multiple/multiple-auto-complete-configuration';


@Component({
  selector: 'app-dmp-wizard-editor-component',
  templateUrl: 'dmp-wizard-editor.component.html',
  styleUrls: ['./dmp-wizard-editor.component.scss'],
  encapsulation: ViewEncapsulation.None
})
export class DataManagementPlanWizardEditorComponent implements AfterViewInit {


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

  filteringOrganisationsAsync: boolean = false;
  filteringResearchersAsync: boolean = false;
  filteredProfilesAsync: boolean = false;
  filteredOrganisations: ExternalSourcesItemModel[];
  filteredResearchers: ExternalSourcesItemModel[];
  filteredProfiles: DatasetProfileModel[];

  projectAutoCompleteConfiguration: SingleAutoCompleteConfiguration;
  profilesAutoCompleteConfiguration: MultipleAutoCompleteConfiguration;
  organisationsAutoCompleteConfiguration: MultipleAutoCompleteConfiguration;
  researchersAutoCompleteConfiguration: MultipleAutoCompleteConfiguration;
  createNewVersion;
  associatedUsers: Array<DmpUsersModel>
  labelDisabled: boolean = false;

  constructor(
    private dataManagementPlanService: DataManagementPlanService,
    private projectService: ProjectService,
    private externalSourcesService: ExternalSourcesService,
    private route: ActivatedRoute,
    public snackBar: MatSnackBar,
    public router: Router,
    public language: TranslateService,
    private _service: DataManagementPlanService,
    private languageResolverService: LanguageResolverService
  ) {

  }

  ngOnInit() {

    let projectRequestItem: RequestItem<ProjectCriteria> = new RequestItem();
    projectRequestItem.criteria = new ProjectCriteria();
    this.projectAutoCompleteConfiguration = {
      filterFn: this.searchProject.bind(this.projectService),
      items: this.searchProject(''),
      displayFn: (item) => item["label"],
      titleFn: (item) => item["label"],
      //mapFn: (item) => new JsonSerializer<ProjectReference>().fromJSONArray(item, ProjectReference).map(item => item.toDropdownList()),
      loadDataOnStart: true
    };

    this.profilesAutoCompleteConfiguration = {
      filterFn: this.filterProfiles.bind(this),
      initialItems: (excludedItems: any[]) => this.filterProfiles('').map(result => result.filter(x => excludedItems.map(x => x.id).indexOf(x.id) == -1)),
      displayFn: (item) => item["label"],
      titleFn: (item) => item["label"],
      //mapFn: (item) => new JsonSerializer<ProjectReference>().fromJSONArray(item, ProjectReference).map(item => item.toDropdownList()),
      loadDataOnStart: true
    };

    this.organisationsAutoCompleteConfiguration = {
      filterFn: this.filterOrganisations.bind(this),
      initialItems: (excludedItems: any[]) => this.filterOrganisations('').map(result => result.filter(x => excludedItems.map(x => x.id).indexOf(x.id) == -1)),
      displayFn: (item) => item["name"],
      titleFn: (item) => item["name"],
      loadDataOnStart: true
    };

    this.researchersAutoCompleteConfiguration = {
      filterFn: this.filterResearchers.bind(this),
      initialItems: (excludedItems: any[]) => this.filterResearchers('').map(result => result.filter(x => excludedItems.map(x => x.id).indexOf(x.id) == -1)),
      displayFn: (item) => item["name"],
      titleFn: (item) => item["name"],
      loadDataOnStart: true
    };

    let organisationRequestItem: RequestItem<BaseCriteria> = new RequestItem();
    organisationRequestItem.criteria = new BaseCriteria();

    this.route.data.subscribe(value => {
      if (value.clone == false && this.formGroup.get("label").value) {
        this.labelDisabled = true;
      }
      this.formGroup.controls["version"].disable();
    })
  }

  searchProject(query: string) {
    let projectRequestItem: RequestItem<ProjectCriteria> = new RequestItem();
    projectRequestItem.criteria = new ProjectCriteria();
    projectRequestItem.criteria.like = query;
    return this.projectService.getWithExternal(projectRequestItem);
  }

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

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

  onSubmit(): void {
    this.dataManagementPlanService.createDataManagementPlan(this.formGroup.getRawValue()).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,
    })
    this.router.navigate(['/dmps']);
  }

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

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

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

  filterOrganisations(value: string): Observable<ExternalSourcesItemModel[]> {

    this.filteredOrganisations = undefined;
    this.filteringOrganisationsAsync = true;

    return this.externalSourcesService.searchDMPOrganizations(value)
  }

  filterResearchers(value: string): Observable<ExternalSourcesItemModel[]> {

    this.filteredResearchers = undefined;
    this.filteringResearchersAsync = true;

    return this.externalSourcesService.searchDMPResearchers({ criteria: { name: value, like: null } })
  }

  filterProfiles(value: string): Observable<DatasetProfileModel[]> {

    this.filteredProfiles = undefined;
    this.filteredProfilesAsync = true;

    const request = new RequestItem<DatasetProfileCriteria>();
    let criteria = new DatasetProfileCriteria();
    criteria.like = value;
    request.criteria = criteria;
    return this._service.searchDMPProfiles(request)
  }

}